[Android Site Settings] Disable fetching important sites when not needed

chrome/browser/android/preferences/website_preference_bridge.cc

 // 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.
 
 #include "chrome/browser/android/preferences/website_preference_bridge.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 627 matching lines @@
     delete this;
   }
 
  private:
   JNIEnv* env_;
   ScopedJavaGlobalRef<jobject> java_callback_;
 };
 
 class LocalStorageInfoReadyCallback {
  public:
-  explicit LocalStorageInfoReadyCallback(const JavaRef<jobject>& java_callback)
+  LocalStorageInfoReadyCallback(const JavaRef<jobject>& java_callback,
+                                bool fetch_important)
       : env_(base::android::AttachCurrentThread()),
-        java_callback_(java_callback) {
-  }
+        java_callback_(java_callback),
+        fetch_important_(fetch_important) {}
 
   void OnLocalStorageModelInfoLoaded(
       Profile* profile,
       const std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>&
           local_storage_info) {
     ScopedJavaLocalRef<jobject> map =
         Java_WebsitePreferenceBridge_createLocalStorageInfoMap(env_);
 
-    std::vector<ImportantSitesUtil::ImportantDomainInfo> important_domains =
-        ImportantSitesUtil::GetImportantRegisterableDomains(profile,
-                                                            kMaxImportantSites);
+    std::vector<ImportantSitesUtil::ImportantDomainInfo> important_domains;
+    if (fetch_important_) {
+      important_domains = ImportantSitesUtil::GetImportantRegisterableDomains(
+          profile, kMaxImportantSites);
+    }
 
     std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::const_iterator
         i;
     for (i = local_storage_info.begin(); i != local_storage_info.end(); ++i) {
       ScopedJavaLocalRef<jstring> full_origin =
           ConvertUTF8ToJavaString(env_, i->origin_url.spec());
       std::string origin_str = i->origin_url.GetOrigin().spec();
+
       bool important = false;
-      std::string registerable_domain;
-      if (i->origin_url.HostIsIPAddress()) {
-        registerable_domain = i->origin_url.host();
-      } else {
-        registerable_domain =
-            net::registry_controlled_domains::GetDomainAndRegistry(
-                i->origin_url,
-                net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
-      }
-      auto important_domain_search = [&registerable_domain](
-          const ImportantSitesUtil::ImportantDomainInfo& item) {
-        return item.registerable_domain == registerable_domain;
-      };
-      if (std::find_if(important_domains.begin(), important_domains.end(),
-                       important_domain_search) != important_domains.end()) {
-        important = true;
+      if (fetch_important_) {
+        std::string registerable_domain;
+        if (i->origin_url.HostIsIPAddress()) {
+          registerable_domain = i->origin_url.host();
+        } else {
+          registerable_domain =
+              net::registry_controlled_domains::GetDomainAndRegistry(
+                  i->origin_url,
+                  net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
+        }
+        auto important_domain_search =
+            [&registerable_domain](
+                const ImportantSitesUtil::ImportantDomainInfo& item) {
+              return item.registerable_domain == registerable_domain;
+            };
+        if (std::find_if(important_domains.begin(), important_domains.end(),
+                         important_domain_search) != important_domains.end()) {
+          important = true;
+        }
       }
       // Remove the trailing slash so the origin is matched correctly in
       // SingleWebsitePreferences.mergePermissionInfoForTopLevelOrigin.
       DCHECK_EQ('/', origin_str.back());
       origin_str.pop_back();
       ScopedJavaLocalRef<jstring> origin =
           ConvertUTF8ToJavaString(env_, origin_str);
       Java_WebsitePreferenceBridge_insertLocalStorageInfoIntoMap(
           env_, map, origin, full_origin, i->size, important);
     }
 
     base::android::RunCallbackAndroid(java_callback_, map);
     delete this;
   }
 
  private:
   JNIEnv* env_;
   ScopedJavaGlobalRef<jobject> java_callback_;
+  bool fetch_important_;
 };
 
 }  // anonymous namespace
 
 // TODO(jknotten): These methods should not be static. Instead we should
 // expose a class to Java so that the fetch requests can be cancelled,
 // and manage the lifetimes of the callback (and indirectly the helper
 // by having a reference to it).
 
 // The helper methods (StartFetching, DeleteLocalStorageFile, DeleteDatabase)
 // are asynchronous. A "use after free" error is not possible because the
 // helpers keep a reference to themselves for the duration of their tasks,
 // which includes callback invocation.
 
 static void FetchLocalStorageInfo(JNIEnv* env,
                                   const JavaParamRef<jclass>& clazz,
-                                  const JavaParamRef<jobject>& java_callback) {
+                                  const JavaParamRef<jobject>& java_callback,
+                                  jboolean fetch_important) {
   Profile* profile = ProfileManager::GetActiveUserProfile();
   scoped_refptr<BrowsingDataLocalStorageHelper> local_storage_helper(
       new BrowsingDataLocalStorageHelper(profile));
   // local_storage_callback will delete itself when it is run.
   LocalStorageInfoReadyCallback* local_storage_callback =
-      new LocalStorageInfoReadyCallback(java_callback);
+      new LocalStorageInfoReadyCallback(java_callback,
+                                        fetch_important == JNI_TRUE);

[Ted C, 2017/06/22 20:06:49]

do you need the == JNI_TRUE here?  In general, I've seen them just call through
w/o this.

[dmurph, 2017/06/23 00:22:48]

No - I can remove it.

   local_storage_helper->StartFetching(
       base::Bind(&LocalStorageInfoReadyCallback::OnLocalStorageModelInfoLoaded,
                  base::Unretained(local_storage_callback), profile));
 }
 
 static void FetchStorageInfo(JNIEnv* env,
                              const JavaParamRef<jclass>& clazz,
                              const JavaParamRef<jobject>& java_callback) {
   Profile* profile = ProfileManager::GetActiveUserProfile();
 
@@ skipping 90 matching lines @@
                                        const JavaParamRef<jstring>& jorigin) {
   GURL url(ConvertJavaStringToUTF8(env, jorigin));
   return !!GetHostContentSettingsMap(false)->GetWebsiteSetting(
       url, GURL(), CONTENT_SETTINGS_TYPE_ADS_DATA, std::string(), nullptr);
 }
 
 // Register native methods
 bool RegisterWebsitePreferenceBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }