[Webview, Child Accounts] Automatically sign in to Chrome if needed.

chrome/android/java/src/org/chromium/chrome/browser/superviseduser/SupervisedUserContentProvider.java

 // Copyright 2015 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.chrome.browser.superviseduser;
 
 import android.annotation.TargetApi;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.SystemClock;
 import android.os.UserManager;
 
+import org.chromium.base.Callback;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.library_loader.LibraryLoader;
 import org.chromium.base.library_loader.ProcessInitException;
 import org.chromium.base.metrics.RecordHistogram;
+import org.chromium.chrome.browser.childaccounts.ChildAccountService;
+import org.chromium.chrome.browser.firstrun.ForcedSigninProcessor;
 import org.chromium.chrome.browser.init.ChromeBrowserInitializer;
+import org.chromium.components.signin.ChromeSigninController;
+import org.chromium.components.supervisedusererrorpage.FilteringBehaviorReason;
 import org.chromium.components.webrestrictions.browser.WebRestrictionsContentProvider;
 
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.TimeUnit;
 
 /**
  * Content provider for telling other apps (e.g. WebView apps) about the supervised user URL filter.
  */
 public class SupervisedUserContentProvider extends WebRestrictionsContentProvider {
     private static final String SUPERVISED_USER_CONTENT_PROVIDER_ENABLED =
             "SupervisedUserContentProviderEnabled";
     private long mNativeSupervisedUserContentProvider;
     private boolean mChromeAlreadyStarted;
     private static Object sEnabledLock = new Object();
+    private static Object sContentProviderLock = new Object();
+
+    private static final String TAG = "SupervisedUserContent";
 
     // Three value "boolean" caching enabled state, null if not yet known.
     private static Boolean sEnabled;
 
-    private long getSupervisedUserContentProvider() throws ProcessInitException {
-        mChromeAlreadyStarted = LibraryLoader.isInitialized();
-        if (mNativeSupervisedUserContentProvider != 0) {
-            return mNativeSupervisedUserContentProvider;
-        }
-
-        ChromeBrowserInitializer.getInstance(getContext()).handleSynchronousStartup();
-
-        mNativeSupervisedUserContentProvider = nativeCreateSupervisedUserContentProvider();
-        return mNativeSupervisedUserContentProvider;
+    @VisibleForTesting
+    void startForcedSigninProcessor(Context appContext, Runnable onComplete) {
+        ForcedSigninProcessor.start(appContext, onComplete);
     }
 
-    void setNativeSupervisedUserContentProviderForTesting(long nativeProvider) {
-        mNativeSupervisedUserContentProvider = nativeProvider;
+    @VisibleForTesting
+    void listenForChildAccountStatusChange(Callback<Boolean> callback) {
+        ChildAccountService.listenForStatusChange(callback);
+    }
+
+    private long getSupervisedUserContentProvider() {
+        // This may lock for some time, but is always called on a background thread, and will only
+        // take significant time if the Chrome process isn't already running.
+        synchronized (sContentProviderLock) {
+            mChromeAlreadyStarted = LibraryLoader.isInitialized();
+            if (mNativeSupervisedUserContentProvider != 0) {
+                return mNativeSupervisedUserContentProvider;
+            }
+            final Context appContext = getContext().getApplicationContext();
+            final SupervisedUserReply<Long> reply = new SupervisedUserReply<>();
+            ThreadUtils.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        ChromeBrowserInitializer.getInstance(appContext).handleSynchronousStartup();
+                    } catch (ProcessInitException e) {
+                        reply.onQueryFinished(0L);
+                        return;
+                    }
+                    final ChromeSigninController chromeSigninController =
+                            ChromeSigninController.get(appContext);
+                    if (chromeSigninController.isSignedIn()) {
+                        reply.onQueryFinished(nativeCreateSupervisedUserContentProvider());
+                        return;
+                    }
+                    // Try to sign in, Chrome needs to be signed in to get the URL filter.
+                    startForcedSigninProcessor(appContext, new Runnable() {
+                        @Override
+                        public void run() {
+                            if (!chromeSigninController.isSignedIn()) {
+                                reply.onQueryFinished(0L);
+                                return;
+                            }
+                            // Wait for the status change; Chrome can't check any URLs until this
+                            // has happened.
+                            listenForChildAccountStatusChange(new Callback<Boolean>() {
+                                @Override
+                                public void onResult(Boolean result) {
+                                    reply.onQueryFinished(
+                                            nativeCreateSupervisedUserContentProvider());
+                                }
+                            });
+                        }
+                    });
+                }
+            });
+            try {
+                Long result = reply.getResult();
+                if (result == null) return 0;
+                mNativeSupervisedUserContentProvider = result;
+                return mNativeSupervisedUserContentProvider;
+            } catch (InterruptedException e) {
+                return 0;
+            }
+        }
     }
 
     static class SupervisedUserReply<T> {
         private static final long RESULT_TIMEOUT_SECONDS = 10;
         final BlockingQueue<T> mQueue = new ArrayBlockingQueue<>(1);
 
         void onQueryFinished(T reply) {
             // This must be called precisely once per query.
             mQueue.add(reply);
         }
@@ skipping 35 matching lines @@
     @Override
     protected WebRestrictionsResult shouldProceed(final String url) {
         // This will be called on multiple threads (but never the UI thread),
         // see http://developer.android.com/guide/components/processes-and-threads.html#ThreadSafe.
         // The reply comes back on a different thread (possibly the UI thread) some time later.
         // As such it needs to correctly match the replies to the calls. It does this by creating a
         // reply object for each query, and passing this through the callback structure. The reply
         // object also handles waiting for the reply.
         long startTimeMs = SystemClock.elapsedRealtime();
         final SupervisedUserQueryReply queryReply = new SupervisedUserQueryReply();
+        final long contentProvider = getSupervisedUserContentProvider();
+        if (contentProvider == 0) {
+            return new WebRestrictionsResult(
+                    false, new int[] {FilteringBehaviorReason.NOT_SIGNED_IN}, null);
+        }
         ThreadUtils.runOnUiThread(new Runnable() {
             @Override
             public void run() {
-                try {
-                    nativeShouldProceed(getSupervisedUserContentProvider(), queryReply, url);
-                } catch (ProcessInitException e) {
-                    queryReply.onQueryFailedNoErrorData();
-                }
+                nativeShouldProceed(contentProvider, queryReply, url);
             }
         });
         try {
             // This will block until an onQueryComplete call on a different thread adds
             // something to the queue.
             WebRestrictionsResult result = queryReply.getResult();
             String histogramName = mChromeAlreadyStarted
                     ? "SupervisedUserContentProvider.ChromeStartedRequestTime"
                     : "SupervisedUserContentProvider.ChromeNotStartedRequestTime";
             RecordHistogram.recordTimesHistogram(histogramName,
@@ skipping 22 matching lines @@
 
     @Override
     protected boolean requestInsert(final String url) {
         // This will be called on multiple threads (but never the UI thread),
         // see http://developer.android.com/guide/components/processes-and-threads.html#ThreadSafe.
         // The reply comes back on a different thread (possibly the UI thread) some time later.
         // As such it needs to correctly match the replies to the calls. It does this by creating a
         // reply object for each query, and passing this through the callback structure. The reply
         // object also handles waiting for the reply.
         final SupervisedUserInsertReply insertReply = new SupervisedUserInsertReply();
+        final long contentProvider = getSupervisedUserContentProvider();
+        if (contentProvider == 0) return false;
         ThreadUtils.runOnUiThread(new Runnable() {
             @Override
             public void run() {
-                try {
-                    nativeRequestInsert(getSupervisedUserContentProvider(), insertReply, url);
-                } catch (ProcessInitException e) {
-                    insertReply.onInsertRequestSendComplete(false);
-                }
+                nativeRequestInsert(contentProvider, insertReply, url);
             }
         });
         try {
             Boolean result = insertReply.getResult();
             if (result == null) return false;
             return result;
         } catch (InterruptedException e) {
             return false;
         }
     }
 
-    @Override
-    public Bundle call(String method, String arg, Bundle bundle) {
-        if (method.equals("setFilterForTesting")) setFilterForTesting();
-        return null;
-    }
-
-    void setFilterForTesting() {
-        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    nativeSetFilterForTesting(getSupervisedUserContentProvider());
-                } catch (ProcessInitException e) {
-                    // There is no way of returning anything sensible here, so ignore the error and
-                    // do nothing.
-                }
-            }
-        });
-    }
-
     @CalledByNative
     void onSupervisedUserFilterUpdated() {
         onFilterChanged();
     }
 
     private static Boolean getEnabled() {
         synchronized (sEnabledLock) {
             return sEnabled;
         }
     }
@@ skipping 31 matching lines @@
     @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
     private void updateEnabledState() {
         // This method uses AppRestrictions directly, rather than using the Policy interface,
         // because it must be callable in contexts in which the native library hasn't been
         // loaded. It will always be called from a background thread (except possibly in tests)
         // so can get the App Restrictions synchronously.
         UserManager userManager = (UserManager) getContext().getSystemService(Context.USER_SERVICE);
         Bundle appRestrictions = userManager
                 .getApplicationRestrictions(getContext().getPackageName());
         setEnabled(appRestrictions.getBoolean(SUPERVISED_USER_CONTENT_PROVIDER_ENABLED));
-    };
+    }
+
+    @Override
+    protected String[] getErrorColumnNames() {
+        String result[] = {"Reason", "Allow access requests", "Is child account",
+                "Profile image URL", "Second profile image URL", "Custodian", "Custodian email",
+                "Second custodian", "Second custodian email"};
+        return result;
+    }
+
+    // Helpers for testing.
+
+    @Override
+    public Bundle call(String method, String arg, Bundle bundle) {
+        if (method.equals("setFilterForTesting")) setFilterForTesting();
+        return null;
+    }
+
+    void setFilterForTesting() {
+        final long contentProvider = getSupervisedUserContentProvider();
+        if (contentProvider == 0) return;
+        ThreadUtils.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                nativeSetFilterForTesting(contentProvider);
+            }
+        });
+    }
+
+    void setNativeSupervisedUserContentProviderForTesting(long nativeProvider) {
+        mNativeSupervisedUserContentProvider = nativeProvider;
+    }
 
     @VisibleForTesting
     public static void enableContentProviderForTesting() {
         setEnabled(true);
     }
 
     native long nativeCreateSupervisedUserContentProvider();
 
     native void nativeShouldProceed(long nativeSupervisedUserContentProvider,
             SupervisedUserQueryReply queryReply, String url);
 
     native void nativeRequestInsert(long nativeSupervisedUserContentProvider,
             SupervisedUserInsertReply insertReply, String url);
 
     private native void nativeSetFilterForTesting(long nativeSupervisedUserContentProvider);
 
-    @Override
-    protected String[] getErrorColumnNames() {
-        String result[] = {"Reason", "Allow access requests", "Is child account",
-                "Profile image URL", "Second profile image URL", "Custodian", "Custodian email",
-                "Second custodian", "Second custodian email"};
-        return result;
-    }
 }