Make WindowAndroid constructor takes context as param.

ui/android/java/src/org/chromium/ui/WindowAndroid.java

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.ui;
 
-import android.app.Activity;
-import android.content.ActivityNotFoundException;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
-import android.graphics.Bitmap;
-import android.graphics.Rect;
 import android.os.Bundle;
 import android.util.Log;
 import android.util.SparseArray;
-import android.view.View;
 import android.widget.Toast;
 
-import java.io.ByteArrayOutputStream;
 import java.util.HashMap;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 
 /**
  * The window base class that has the minimum functionality.
  */
 @JNINamespace("ui")
 public class WindowAndroid {
+    private static void logActivityRequiredWarning() {
+        Log.w(TAG, "A Context of type Activity is required.");
+    }
 
     private static final String TAG = "WindowAndroid";
 
     // Native pointer to the c++ WindowAndroid object.
     private int mNativeWindowAndroid = 0;
 
-    // Constants used for intent request code bounding.
-    private static final int REQUEST_CODE_PREFIX = 1000;
-    private static final int REQUEST_CODE_RANGE_SIZE = 100;
     // A string used as a key to store intent errors in a bundle
     static final String WINDOW_CALLBACK_ERRORS = "window_callback_errors";
 
-    private int mNextRequestCode = 0;
-    protected Activity mActivity;
     protected Context mApplicationContext;
     protected SparseArray<IntentCallback> mOutstandingIntents;
     protected HashMap<Integer, String> mIntentErrors;
 
     /**
-     * @param activity
+     * @param context, the application context..
      */
-    public WindowAndroid(Activity activity) {
-        mActivity = activity;
-        mApplicationContext = mActivity.getApplicationContext();
+    public WindowAndroid(Context context) {
+        assert context == context.getApplicationContext();
+        mApplicationContext = context;
         mOutstandingIntents = new SparseArray<IntentCallback>();
         mIntentErrors = new HashMap<Integer, String>();
-
     }
 
     /**
      * Shows an intent and returns the results to the callback object.
      * @param intent The intent that needs to be showed.
      * @param callback The object that will receive the results for the intent.
      * @param errorId The ID of error string to be show if activity is paused before intent
      *        results.
      * @return Whether the intent was shown.
      */
     public boolean showIntent(Intent intent, IntentCallback callback, int errorId) {
-        int requestCode = REQUEST_CODE_PREFIX + mNextRequestCode;
-        mNextRequestCode = (mNextRequestCode + 1) % REQUEST_CODE_RANGE_SIZE;
-
-        try {
-            mActivity.startActivityForResult(intent, requestCode);
-        } catch (ActivityNotFoundException e) {
-            return false;
-        }
-
-        mOutstandingIntents.put(requestCode, callback);
-        mIntentErrors.put(requestCode, mActivity.getString(errorId));
-
-        return true;
+        logActivityRequiredWarning();

[joth, 2013/11/01 23:12:18]

I think you'd be better having a clearer log here:
Log.d(TAG, "Can't show intent as context is not an Activity: " + intent);

And then dropping the other logActivityRequiredWarning() calls -- they're not
really going to help anyone.

[michaelbai, 2013/11/07 21:10:03]

Done.

+        return false;
     }
 
     /**
      * Displays an error message with a provided error message string.
      * @param error The error message string to be displayed.
      */
     public void showError(String error) {
         if (error != null) {
-            Toast.makeText(mActivity, error, Toast.LENGTH_SHORT).show();
+            Toast.makeText(mApplicationContext, error, Toast.LENGTH_SHORT).show();
         }
     }
 
     /**
      * Displays an error message from the given resource id.
      * @param resId The error message string's resource id.
      */
     public void showError(int resId) {
-        showError(mActivity.getString(resId));
+        showError(mApplicationContext.getString(resId));
     }
 
     /**
      * Displays an error message for a nonexistent callback.
      * @param error The error message string to be displayed.
      */
     protected void showCallbackNonExistentError(String error) {
         showError(error);
     }
 
     /**
      * Broadcasts the given intent to all interested BroadcastReceivers.
      */
     public void sendBroadcast(Intent intent) {
-        mActivity.sendBroadcast(intent);
+        mApplicationContext.sendBroadcast(intent);
     }
 
     /**
      * TODO(nileshagrawal): Stop returning Activity Context crbug.com/233440.
-     * @return Activity context.
+     * @return Activity context, it could be null. Note, in most cases, you probably
+     * just need Application Context returned by getApplicationContext().
      * @see #getApplicationContext()
      */
     @Deprecated
     public Context getContext() {
-        return mActivity;
+        logActivityRequiredWarning();
+        return null;
     }
 
     /**
      * @return The application context for this activity.
      */
     public Context getApplicationContext() {
         return mApplicationContext;
     }
 
     /**
@@ skipping 22 matching lines @@
     }
 
     /**
      * Responds to the intent result if the intent was created by the native window.
      * @param requestCode Request code of the requested intent.
      * @param resultCode Result code of the requested intent.
      * @param data The data returned by the intent.
      * @return Boolean value of whether the intent was started by the native window.
      */
     public boolean onActivityResult(int requestCode, int resultCode, Intent data) {
-        IntentCallback callback = mOutstandingIntents.get(requestCode);
-        mOutstandingIntents.delete(requestCode);
-        String errorMessage = mIntentErrors.remove(requestCode);
-
-        if (callback != null) {
-            callback.onIntentCompleted(this, resultCode,
-                    mActivity.getContentResolver(), data);
-            return true;
-        } else {
-            if (errorMessage != null) {
-                showCallbackNonExistentError(errorMessage);
-                return true;
-            }
-        }
+        logActivityRequiredWarning();
         return false;
     }
 
     /**
      * An interface that intent callback objects have to implement.
      */
     public interface IntentCallback {
         /**
          * Handles the data returned by the requested intent.
          * @param window A window reference.
@@ skipping 26 matching lines @@
         }
         return mNativeWindowAndroid;
     }
 
     /**
      * Returns a PNG-encoded screenshot of the the window region at (|windowX|,
      * |windowY|) with the size |width| by |height| pixels.
      */
     @CalledByNative
     public byte[] grabSnapshot(int windowX, int windowY, int width, int height) {
-        try {
-            // Take a screenshot of the root activity view. This generally includes UI
-            // controls such as the URL bar and OS windows such as the status bar.
-            View rootView = mActivity.findViewById(android.R.id.content).getRootView();
-            Bitmap bitmap = UiUtils.generateScaledScreenshot(rootView, 0, Bitmap.Config.ARGB_8888);
-            if (bitmap == null) return null;
-
-            // Clip the result into the requested region.
-            if (windowX > 0 || windowY > 0 || width != bitmap.getWidth() ||
-                    height != bitmap.getHeight()) {
-                Rect clip = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
-                clip.intersect(windowX, windowY, windowX + width, windowY + height);
-                bitmap = Bitmap.createBitmap(
-                        bitmap, clip.left, clip.top, clip.width(), clip.height());
-            }
-
-            // Compress the result into a PNG.
-            ByteArrayOutputStream result = new ByteArrayOutputStream();
-            if (!bitmap.compress(Bitmap.CompressFormat.PNG, 100, result)) return null;
-            bitmap.recycle();
-            return result.toByteArray();
-        } catch (OutOfMemoryError e) {
-            Log.e(TAG, "Out of memory while grabbing window snapshot.", e);
-            return null;
-        }
+        logActivityRequiredWarning();
+        return null;
     }
 
     private native int nativeInit();
     private native void nativeDestroy(int nativeWindowAndroid);
 
 }