Simplify synchronous fetching in WebsitePermissionsFetcher.

chrome/android/java/src/org/chromium/chrome/browser/preferences/website/WebsitePermissionsFetcher.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.preferences.website;
 
 import org.chromium.chrome.browser.ContentSettingsType;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ skipping 144 matching lines @@
     private Set<Website> findOrCreateSitesByHost(WebsiteAddress address) {
         String host = address.getHost();
         if (!mSitesByHost.containsKey(host)) {
             mSitesByHost.put(host, new HashSet<Website>());
             mSitesByHost.get(host).add(new Website(address));
         }
         return mSitesByHost.get(host);
     }
 
     /**
-     * A single task in the WebsitePermissionsFetcher task queue. We need
-     * fetching of features to be serialized, as we need to have all the origins
-     * in place prior to populating the hosts.
+     * A single task in the WebsitePermissionsFetcher task queue. We need fetching of features to be
+     * serialized, as we need to have all the origins in place prior to populating the hosts.
      */
-    private interface Task {
-        void run(TaskQueue queue);
+    private abstract class Task {
+        /** Override this method to implement a synchronous task. */
+        void run() {}
+
+        /**
+         * Override this method to implement an asynchronous task. Call queue.next() once execution
+         * is complete.
+         */
+        void runAsync(TaskQueue queue) {
+            run();
+            queue.next();
+        }
     }
 
     /**
-     * A queue used to store the sequence of tasks to run to fetch the website
-     * preferences. Each task is run sequentially (although the queue as a whole
-     * is run asynchronously). Each task should call queue.next() at the end to
-     * run the next task in the queue.
+     * A queue used to store the sequence of tasks to run to fetch the website preferences. Each
+     * task is run sequentially, and some of the tasks may run asynchronously.
      */
     private static class TaskQueue extends LinkedList<Task> {
         void next() {
-            if (!isEmpty()) removeFirst().run(this);
+            if (!isEmpty()) removeFirst().runAsync(this);
         }
     }
 
-    private class GeolocationInfoFetcher implements Task {
+    private class GeolocationInfoFetcher extends Task {
         @Override
-        public void run(TaskQueue queue) {
+        public void run() {
             for (GeolocationInfo info : WebsitePreferenceBridge.getGeolocationInfo()) {
                 WebsiteAddress address = WebsiteAddress.create(info.getOrigin());
                 if (address == null) continue;
                 createSiteByOriginAndHost(address).setGeolocationInfo(info);
             }
-            queue.next();
         }
     }
 
-    private class MidiInfoFetcher implements Task {
+    private class MidiInfoFetcher extends Task {
         @Override
-        public void run(TaskQueue queue) {
+        public void run() {
             for (MidiInfo info : WebsitePreferenceBridge.getMidiInfo()) {
                 WebsiteAddress address = WebsiteAddress.create(info.getOrigin());
                 if (address == null) continue;
                 createSiteByOriginAndHost(address).setMidiInfo(info);
             }
-            queue.next();
         }
     }
 
-    private class PopupExceptionInfoFetcher implements Task {
+    private class PopupExceptionInfoFetcher extends Task {
         @Override
-        public void run(TaskQueue queue) {
+        public void run() {
             for (ContentSettingException exception :
                     WebsitePreferenceBridge.getContentSettingsExceptions(
                             ContentSettingsType.CONTENT_SETTINGS_TYPE_POPUPS)) {
                 // The pattern "*" represents the default setting, not a
                 // specific website.
                 if (exception.getPattern().equals("*")) continue;
                 WebsiteAddress address = WebsiteAddress.create(exception.getPattern());
                 if (address == null) continue;
                 Set<Website> sites = findOrCreateSitesByHost(address);
                 for (Website site : sites) {
                     site.setPopupException(exception);
                 }
             }
-            queue.next();
         }
     }
 
-    private class JavaScriptExceptionInfoFetcher implements Task {
+    private class JavaScriptExceptionInfoFetcher extends Task {
         @Override
-        public void run(TaskQueue queue) {
+        public void run() {
             for (ContentSettingException exception
                     : WebsitePreferenceBridge.getContentSettingsExceptions(
                             ContentSettingsType.CONTENT_SETTINGS_TYPE_JAVASCRIPT)) {
                 // The pattern "*" represents the default setting, not a specific website.
                 if (exception.getPattern().equals("*")) continue;
                 WebsiteAddress address = WebsiteAddress.create(exception.getPattern());
                 if (address == null) continue;
                 Set<Website> sites = findOrCreateSitesByHost(address);
                 for (Website site : sites) {
                     site.setJavaScriptException(exception);
                 }
             }
-            queue.next();
         }
     }
 
-    private class CookieInfoFetcher implements Task {
+    private class CookieInfoFetcher extends Task {
         @Override
-        public void run(TaskQueue queue) {
+        public void run() {
             for (CookieInfo info : WebsitePreferenceBridge.getCookieInfo()) {
                 WebsiteAddress address = WebsiteAddress.create(info.getOrigin());
                 if (address == null) continue;
                 createSiteByOriginAndHost(address).setCookieInfo(info);
             }
-            queue.next();
         }
     }
 
     /**
      * Class for fetching the fullscreen information.
      */
-    private class FullscreenInfoFetcher implements Task {
+    private class FullscreenInfoFetcher extends Task {
         @Override
-        public void run(TaskQueue queue) {
+        public void run() {
             for (FullscreenInfo info : WebsitePreferenceBridge.getFullscreenInfo()) {
                 WebsiteAddress address = WebsiteAddress.create(info.getOrigin());
                 if (address == null) continue;
                 createSiteByOriginAndHost(address).setFullscreenInfo(info);
             }
-            queue.next();
         }
     }
 
-    private class LocalStorageInfoFetcher implements Task {
+    private class LocalStorageInfoFetcher extends Task {
         @Override
-        public void run(final TaskQueue queue) {
+        public void runAsync(final TaskQueue queue) {
             WebsitePreferenceBridge.fetchLocalStorageInfo(
                     new WebsitePreferenceBridge.LocalStorageInfoReadyCallback() {
                         @SuppressWarnings("unchecked")
                         @Override
                         public void onLocalStorageInfoReady(HashMap map) {
                             for (Object o : map.entrySet()) {
                                 Map.Entry<String, LocalStorageInfo> entry =
                                         (Map.Entry<String, LocalStorageInfo>) o;
                                 WebsiteAddress address = WebsiteAddress.create(entry.getKey());
                                 if (address == null) continue;
                                 Set<Website> sites = findOrCreateSitesByOrigin(address);
                                 for (Website site : sites) {
                                     site.setLocalStorageInfo(entry.getValue());
                                 }
                             }
                             queue.next();
                         }
                     });
         }
     }
 
-    private class WebStorageInfoFetcher implements Task {
+    private class WebStorageInfoFetcher extends Task {
         @Override
-        public void run(final TaskQueue queue) {
+        public void runAsync(final TaskQueue queue) {
             WebsitePreferenceBridge.fetchStorageInfo(
                     new WebsitePreferenceBridge.StorageInfoReadyCallback() {
                         @SuppressWarnings("unchecked")
                         @Override
                         public void onStorageInfoReady(ArrayList array) {
                             ArrayList<StorageInfo> infoArray = array;
                             for (StorageInfo info : infoArray) {
                                 WebsiteAddress address = WebsiteAddress.create(info.getHost());
                                 if (address == null) continue;
                                 Set<Website> sites = findOrCreateSitesByHost(address);
                                 for (Website site : sites) {
                                     site.addStorageInfo(info);
                                 }
                             }
                             queue.next();
                         }
                     });
         }
     }
 
-    private class ProtectedMediaIdentifierInfoFetcher implements Task {
+    private class ProtectedMediaIdentifierInfoFetcher extends Task {
         @Override
-        public void run(TaskQueue queue) {
+        public void run() {
             for (ProtectedMediaIdentifierInfo info :
                     WebsitePreferenceBridge.getProtectedMediaIdentifierInfo()) {
                 WebsiteAddress address = WebsiteAddress.create(info.getOrigin());
                 if (address == null) continue;
                 createSiteByOriginAndHost(address).setProtectedMediaIdentifierInfo(info);
             }
-            queue.next();
         }
     }
 
-    private class PushNotificationInfoFetcher implements Task {
+    private class PushNotificationInfoFetcher extends Task {
         @Override
-        public void run(TaskQueue queue) {
+        public void run() {
             for (PushNotificationInfo info : WebsitePreferenceBridge.getPushNotificationInfo()) {
                 WebsiteAddress address = WebsiteAddress.create(info.getOrigin());
                 if (address == null) continue;
                 createSiteByOriginAndHost(address).setPushNotificationInfo(info);
             }
-            queue.next();
         }
     }
 
-    private class CameraCaptureInfoFetcher implements Task {
+    private class CameraCaptureInfoFetcher extends Task {
         @Override
-        public void run(TaskQueue queue) {
+        public void run() {
             for (CameraInfo info : WebsitePreferenceBridge.getCameraInfo()) {
                 WebsiteAddress address = WebsiteAddress.create(info.getOrigin());
                 if (address == null) continue;
                 createSiteByOriginAndHost(address).setCameraInfo(info);
             }
-            queue.next();
         }
     }
 
-    private class MicrophoneCaptureInfoFetcher implements Task {
+    private class MicrophoneCaptureInfoFetcher extends Task {
         @Override
-        public void run(TaskQueue queue) {
+        public void run() {
             for (MicrophoneInfo info : WebsitePreferenceBridge.getMicrophoneInfo()) {
                 WebsiteAddress address = WebsiteAddress.create(info.getOrigin());
                 if (address == null) continue;
                 createSiteByOriginAndHost(address).setMicrophoneInfo(info);
             }
-            queue.next();
         }
     }
 
-    private class PermissionsAvailableCallbackRunner implements Task {
+    private class PermissionsAvailableCallbackRunner extends Task {
         @Override
-        public void run(TaskQueue queue) {
+        public void run() {
             mCallback.onWebsitePermissionsAvailable(mSitesByOrigin, mSitesByHost);
-            queue.next();
         }
     }
 }