Pull the Activity context from WindowAndroid if possible

ui/android/java/src/org/chromium/ui/base/ActivityWindowAndroid.java

 // Copyright 2013 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.base;
 
 import android.app.Activity;
 import android.app.PendingIntent;
 import android.content.ActivityNotFoundException;
+import android.content.Context;
 import android.content.Intent;
 import android.content.IntentSender.SendIntentException;
 import android.content.SharedPreferences;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.pm.PermissionInfo;
 import android.os.Build;
 import android.os.Handler;
 import android.os.Process;
 import android.preference.PreferenceManager;
@@ skipping 14 matching lines @@
  */
 public class ActivityWindowAndroid
         extends WindowAndroid
         implements ApplicationStatus.ActivityStateListener, View.OnLayoutChangeListener {
     // Constants used for intent request code bounding.
     private static final int REQUEST_CODE_PREFIX = 1000;
     private static final int REQUEST_CODE_RANGE_SIZE = 100;
 
     private static final String PERMISSION_QUERIED_KEY_PREFIX = "HasRequestedAndroidPermission::";
 
-    private final WeakReference<Activity> mActivityRef;
     private final Handler mHandler;
     private final SparseArray<PermissionCallback> mOutstandingPermissionRequests;
 
     private int mNextRequestCode = 0;
 
     /**
      * Creates an Activity-specific WindowAndroid with associated intent functionality.
      * TODO(jdduke): Remove this overload when all callsites have been updated to
      * indicate their activity state listening preference.
-     * @param activity The activity associated with the WindowAndroid.
+     * @param context Context wrapping an activity associated with the WindowAndroid.
      */
-    public ActivityWindowAndroid(Activity activity) {
-        this(activity, true);
+    public ActivityWindowAndroid(Context context) {
+        this(context, true);
     }
 
     /**
      * Creates an Activity-specific WindowAndroid with associated intent functionality.
-     * @param activity The activity associated with the WindowAndroid.
+     * @param context Context wrapping an activity associated with the WindowAndroid.
      * @param listenToActivityState Whether to listen to activity state changes.
      */
-    public ActivityWindowAndroid(Activity activity, boolean listenToActivityState) {
-        super(activity.getApplicationContext());
-        mActivityRef = new WeakReference<Activity>(activity);
+    public ActivityWindowAndroid(Context context, boolean listenToActivityState) {
+        super(context);
+        Activity activity = activityFromContext(context);
+        if (activity == null) {
+            throw new IllegalArgumentException("Context is not and does not wrap an Activity");
+        }
         mHandler = new Handler();
         mOutstandingPermissionRequests = new SparseArray<PermissionCallback>();
         if (listenToActivityState) {
             ApplicationStatus.registerStateListenerForActivity(this, activity);
         }
 
         setAndroidPermissionDelegate(new ActivityAndroidPermissionDelegate());
     }
 
     @Override
     protected void registerKeyboardVisibilityCallbacks() {
-        Activity activity = mActivityRef.get();
+        Activity activity = getActivity().get();
         if (activity == null) return;
         View content = activity.findViewById(android.R.id.content);
-        mIsKeyboardShowing = UiUtils.isKeyboardShowing(mActivityRef.get(), content);
+        mIsKeyboardShowing = UiUtils.isKeyboardShowing(getActivity().get(), content);
         content.addOnLayoutChangeListener(this);
     }
 
     @Override
     protected void unregisterKeyboardVisibilityCallbacks() {
-        Activity activity = mActivityRef.get();
+        Activity activity = getActivity().get();
         if (activity == null) return;
         activity.findViewById(android.R.id.content).removeOnLayoutChangeListener(this);
     }
 
     @Override
     public int showCancelableIntent(
             PendingIntent intent, IntentCallback callback, Integer errorId) {
-        Activity activity = mActivityRef.get();
+        Activity activity = getActivity().get();
         if (activity == null) return START_INTENT_FAILURE;
 
         int requestCode = generateNextRequestCode();
 
         try {
             activity.startIntentSenderForResult(
                     intent.getIntentSender(), requestCode, new Intent(), 0, 0, 0);
         } catch (SendIntentException e) {
             return START_INTENT_FAILURE;
         }
 
         storeCallbackData(requestCode, callback, errorId);
         return requestCode;
     }
 
     @Override
     public int showCancelableIntent(Intent intent, IntentCallback callback, Integer errorId) {
-        Activity activity = mActivityRef.get();
+        Activity activity = getActivity().get();
         if (activity == null) return START_INTENT_FAILURE;
 
         int requestCode = generateNextRequestCode();
 
         try {
             activity.startActivityForResult(intent, requestCode);
         } catch (ActivityNotFoundException e) {
             return START_INTENT_FAILURE;
         }
 
         storeCallbackData(requestCode, callback, errorId);
         return requestCode;
     }
 
     @Override
     public void cancelIntent(int requestCode) {
-        Activity activity = mActivityRef.get();
+        Activity activity = getActivity().get();
         if (activity == null) return;
         activity.finishActivity(requestCode);
     }
 
     /**
      * 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.
@@ skipping 41 matching lines @@
 
     /**
      * Responds to a pending permission result.
      * @param requestCode The unique code for the permission request.
      * @param permissions The list of permissions in the result.
      * @param grantResults Whether the permissions were granted.
      * @return Whether the permission request corresponding to a pending permission request.
      */
     public boolean onRequestPermissionsResult(int requestCode, String[] permissions,
             int[] grantResults) {
-        Activity activity = mActivityRef.get();
+        Activity activity = getActivity().get();
         assert activity != null;
 
         SharedPreferences.Editor editor =
                 PreferenceManager.getDefaultSharedPreferences(activity).edit();
         for (int i = 0; i < permissions.length; i++) {
             editor.putBoolean(getHasRequestedPermissionKey(permissions[i]), true);
         }
         editor.apply();
 
         PermissionCallback callback = mOutstandingPermissionRequests.get(requestCode);
         mOutstandingPermissionRequests.delete(requestCode);
         if (callback == null) return false;
         callback.onRequestPermissionsResult(permissions, grantResults);
         return true;
     }
 
     @Override
     public WeakReference<Activity> getActivity() {
-        // Return a new WeakReference to prevent clients from releasing our internal WeakReference.
-        return new WeakReference<Activity>(mActivityRef.get());
+        return new WeakReference<Activity>(activityFromContext(getContext().get()));
     }
 
     @Override
     public void onActivityStateChange(Activity activity, int newState) {
         if (newState == ActivityState.STOPPED) {
             onActivityStopped();
         } else if (newState == ActivityState.STARTED) {
             onActivityStarted();
         }
     }
 
     @Override
     public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft,
             int oldTop, int oldRight, int oldBottom) {
-        keyboardVisibilityPossiblyChanged(UiUtils.isKeyboardShowing(mActivityRef.get(), v));
+        keyboardVisibilityPossiblyChanged(UiUtils.isKeyboardShowing(getActivity().get(), v));
     }
 
     private int generateNextRequestCode() {
         int requestCode = REQUEST_CODE_PREFIX + mNextRequestCode;
         mNextRequestCode = (mNextRequestCode + 1) % REQUEST_CODE_RANGE_SIZE;
         return requestCode;
     }
 
     private void storeCallbackData(int requestCode, IntentCallback callback, Integer errorId) {
         mOutstandingIntents.put(requestCode, callback);
         mIntentErrors.put(
                 requestCode, errorId == null ? null : mApplicationContext.getString(errorId));
     }
 
     private class ActivityAndroidPermissionDelegate implements AndroidPermissionDelegate {
         @Override
         public boolean hasPermission(String permission) {
             return mApplicationContext.checkPermission(permission, Process.myPid(), Process.myUid())
                     == PackageManager.PERMISSION_GRANTED;
         }
 
         @Override
         public boolean canRequestPermission(String permission) {
             if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return false;
 
-            Activity activity = mActivityRef.get();
+            Activity activity = getActivity().get();
             if (activity == null) return false;
 
             if (isPermissionRevokedByPolicy(permission)) {
                 return false;
             }
 
             if (activity.shouldShowRequestPermissionRationale(permission)) {
                 return true;
             }
 
             // Check whether we have ever asked for this permission by checking whether we saved
             // a preference associated with it before.
             String permissionQueriedKey = getHasRequestedPermissionKey(permission);
             SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
             if (!prefs.getBoolean(permissionQueriedKey, false)) return true;
 
             return false;
         }
 
         @Override
         public boolean isPermissionRevokedByPolicy(String permission) {
             if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return false;
 
-            Activity activity = mActivityRef.get();
+            Activity activity = getActivity().get();
             if (activity == null) return false;
 
             return activity.getPackageManager().isPermissionRevokedByPolicy(
                     permission, activity.getPackageName());
         }
 
         @Override
         public void requestPermissions(
                 final String[] permissions, final PermissionCallback callback) {
             if (requestPermissionsInternal(permissions, callback)) return;
@@ skipping 15 matching lines @@
                 }
             });
         }
 
         /**
          * Issues the permission request and returns whether it was sent successfully.
          */
         private boolean requestPermissionsInternal(
                 String[] permissions, PermissionCallback callback) {
             if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return false;
-            Activity activity = mActivityRef.get();
+            Activity activity = getActivity().get();
             if (activity == null) return false;
 
             int requestCode = generateNextRequestCode();
             mOutstandingPermissionRequests.put(requestCode, callback);
             activity.requestPermissions(permissions, requestCode);
             return true;
         }
     }
 }