Minor code cleanup in loaders.

Change-Id: I38147eb9e494b53d41ca3cad042d804631916941

1 files changed, 17 insertions, 17 deletions

diff --git a/core/java/android/content/AsyncTaskLoader.java b/core/java/android/content/AsyncTaskLoader.java
index eb7426e4b261..7241e0d1f2b4 100644
--- a/core/java/android/content/AsyncTaskLoader.java
+++ b/core/java/android/content/AsyncTaskLoader.java
@@ -20,7 +20,7 @@ import android.os.AsyncTask;
 import android.os.Handler;
 import android.os.OperationCanceledException;
 import android.os.SystemClock;
-import android.util.Slog;
+import android.util.Log;
 import android.util.TimeUtils;
 
 import java.io.FileDescriptor;
@@ -64,10 +64,10 @@ public abstract class AsyncTaskLoader<D> extends Loader<D> {
         /* Runs on a worker thread */
         @Override
         protected D doInBackground(Void... params) {
-            if (DEBUG) Slog.v(TAG, this + " >>> doInBackground");
+            if (DEBUG) Log.v(TAG, this + " >>> doInBackground");
             try {
                 D data = AsyncTaskLoader.this.onLoadInBackground();
-                if (DEBUG) Slog.v(TAG, this + "  <<< doInBackground");
+                if (DEBUG) Log.v(TAG, this + "  <<< doInBackground");
                 return data;
             } catch (OperationCanceledException ex) {
                 if (!isCancelled()) {
@@ -79,7 +79,7 @@ public abstract class AsyncTaskLoader<D> extends Loader<D> {
                     // So we treat this case as an unhandled exception.
                     throw ex;
                 }
-                if (DEBUG) Slog.v(TAG, this + "  <<< doInBackground (was canceled)", ex);
+                if (DEBUG) Log.v(TAG, this + "  <<< doInBackground (was canceled)", ex);
                 return null;
             }
         }
@@ -87,7 +87,7 @@ public abstract class AsyncTaskLoader<D> extends Loader<D> {
         /* Runs on the UI thread */
         @Override
         protected void onPostExecute(D data) {
-            if (DEBUG) Slog.v(TAG, this + " onPostExecute");
+            if (DEBUG) Log.v(TAG, this + " onPostExecute");
             try {
                 AsyncTaskLoader.this.dispatchOnLoadComplete(this, data);
             } finally {
@@ -98,7 +98,7 @@ public abstract class AsyncTaskLoader<D> extends Loader<D> {
         /* Runs on the UI thread */
         @Override
         protected void onCancelled(D data) {
-            if (DEBUG) Slog.v(TAG, this + " onCancelled");
+            if (DEBUG) Log.v(TAG, this + " onCancelled");
             try {
                 AsyncTaskLoader.this.dispatchOnCancelled(this, data);
             } finally {
@@ -162,18 +162,18 @@ public abstract class AsyncTaskLoader<D> extends Loader<D> {
         super.onForceLoad();
         cancelLoad();
         mTask = new LoadTask();
-        if (DEBUG) Slog.v(TAG, "Preparing load: mTask=" + mTask);
+        if (DEBUG) Log.v(TAG, "Preparing load: mTask=" + mTask);
         executePendingTask();
     }
 
     @Override
     protected boolean onCancelLoad() {
-        if (DEBUG) Slog.v(TAG, "onCancelLoad: mTask=" + mTask);
+        if (DEBUG) Log.v(TAG, "onCancelLoad: mTask=" + mTask);
         if (mTask != null) {
             if (mCancellingTask != null) {
                 // There was a pending task already waiting for a previous
                 // one being canceled; just drop it.
-                if (DEBUG) Slog.v(TAG,
+                if (DEBUG) Log.v(TAG,
                         "cancelLoad: still waiting for cancelled task; dropping next");
                 if (mTask.waiting) {
                     mTask.waiting = false;
@@ -184,14 +184,14 @@ public abstract class AsyncTaskLoader<D> extends Loader<D> {
             } else if (mTask.waiting) {
                 // There is a task, but it is waiting for the time it should
                 // execute.  We can just toss it.
-                if (DEBUG) Slog.v(TAG, "cancelLoad: task is waiting, dropping it");
+                if (DEBUG) Log.v(TAG, "cancelLoad: task is waiting, dropping it");
                 mTask.waiting = false;
                 mHandler.removeCallbacks(mTask);
                 mTask = null;
                 return false;
             } else {
                 boolean cancelled = mTask.cancel(false);
-                if (DEBUG) Slog.v(TAG, "cancelLoad: cancelled=" + cancelled);
+                if (DEBUG) Log.v(TAG, "cancelLoad: cancelled=" + cancelled);
                 if (cancelled) {
                     mCancellingTask = mTask;
                     cancelLoadInBackground();
@@ -223,7 +223,7 @@ public abstract class AsyncTaskLoader<D> extends Loader<D> {
                 long now = SystemClock.uptimeMillis();
                 if (now < (mLastLoadCompleteTime+mUpdateThrottle)) {
                     // Not yet time to do another load.
-                    if (DEBUG) Slog.v(TAG, "Waiting until "
+                    if (DEBUG) Log.v(TAG, "Waiting until "
                             + (mLastLoadCompleteTime+mUpdateThrottle)
                             + " to execute: " + mTask);
                     mTask.waiting = true;
@@ -231,7 +231,7 @@ public abstract class AsyncTaskLoader<D> extends Loader<D> {
                     return;
                 }
             }
-            if (DEBUG) Slog.v(TAG, "Executing: " + mTask);
+            if (DEBUG) Log.v(TAG, "Executing: " + mTask);
             mTask.executeOnExecutor(mExecutor, (Void[]) null);
         }
     }
@@ -239,11 +239,11 @@ public abstract class AsyncTaskLoader<D> extends Loader<D> {
     void dispatchOnCancelled(LoadTask task, D data) {
         onCanceled(data);
         if (mCancellingTask == task) {
-            if (DEBUG) Slog.v(TAG, "Cancelled task is now canceled!");
+            if (DEBUG) Log.v(TAG, "Cancelled task is now canceled!");
             rollbackContentChanged();
             mLastLoadCompleteTime = SystemClock.uptimeMillis();
             mCancellingTask = null;
-            if (DEBUG) Slog.v(TAG, "Delivering cancellation");
+            if (DEBUG) Log.v(TAG, "Delivering cancellation");
             deliverCancellation();
             executePendingTask();
         }
@@ -251,7 +251,7 @@ public abstract class AsyncTaskLoader<D> extends Loader<D> {
 
     void dispatchOnLoadComplete(LoadTask task, D data) {
         if (mTask != task) {
-            if (DEBUG) Slog.v(TAG, "Load complete of old task, trying to cancel");
+            if (DEBUG) Log.v(TAG, "Load complete of old task, trying to cancel");
             dispatchOnCancelled(task, data);
         } else {
             if (isAbandoned()) {
@@ -261,7 +261,7 @@ public abstract class AsyncTaskLoader<D> extends Loader<D> {
                 commitContentChanged();
                 mLastLoadCompleteTime = SystemClock.uptimeMillis();
                 mTask = null;
-                if (DEBUG) Slog.v(TAG, "Delivering result");
+                if (DEBUG) Log.v(TAG, "Delivering result");
                 deliverResult(data);
             }
         }