(Owner approval for) Delay network requests on startup if any webRequest ...

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2011 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/extensions/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
@@ skipping 71 matching lines @@
 const char kPrefIncognitoEnabled[] = "incognito";
 
 // A preference to control whether an extension is allowed to inject script in
 // pages with file URLs.
 const char kPrefAllowFileAccess[] = "newAllowFileAccess";
 // TODO(jstritar): As part of fixing http://crbug.com/91577, we revoked all
 // extension file access by renaming the pref. We should eventually clean up
 // the old flag and possibly go back to that name.
 // const char kPrefAllowFileAccessOld[] = "allowFileAccess";
 
+// A preference indicating that the extension wants to delay network requests
+// on browser launch until it indicates it's ready. For example, an extension
+// using the webRequest API might want to ensure that no requests are sent
+// before it has registered its event handlers.
+const char kPrefDelayNetworkRequests[] = "delayNetworkRequests";
+
 // A preference set by the web store to indicate login information for
 // purchased apps.
 const char kWebStoreLogin[] = "extensions.webstore_login";
 
 // A preference set by the the NTP to persist the desired launch container type
 // used for apps.
 const char kPrefLaunchType[] = "launchType";
 
 // A preference determining the order of which the apps appear on the NTP.
 const char kPrefAppLaunchIndex[] = "app_launcher_index";
@@ skipping 768 matching lines @@
   UpdateExtensionPref(extension_id, kPrefAllowFileAccess,
                       Value::CreateBooleanValue(allow));
 }
 
 bool ExtensionPrefs::HasAllowFileAccessSetting(
     const std::string& extension_id) const {
   const DictionaryValue* ext = GetExtensionPref(extension_id);
   return ext && ext->HasKey(kPrefAllowFileAccess);
 }
 
+void ExtensionPrefs::SetDelaysNetworkRequests(const std::string& extension_id,
+                                              bool does_delay) {
+  if (does_delay) {
+    UpdateExtensionPref(extension_id, kPrefDelayNetworkRequests,
+                        Value::CreateBooleanValue(true));
+  } else {
+    // Remove the pref.
+    UpdateExtensionPref(extension_id, kPrefDelayNetworkRequests, NULL);
+  }
+}
+
+bool ExtensionPrefs::DelaysNetworkRequests(const std::string& extension_id) {
+  return ReadExtensionPrefBoolean(extension_id, kPrefDelayNetworkRequests);
+}
+
 ExtensionPrefs::LaunchType ExtensionPrefs::GetLaunchType(
     const std::string& extension_id,
     ExtensionPrefs::LaunchType default_pref_value) {
   int value = -1;
   LaunchType result = LAUNCH_REGULAR;
 
   if (ReadExtensionPrefInteger(extension_id, kPrefLaunchType, &value) &&
      (value == LAUNCH_PINNED ||
       value == LAUNCH_REGULAR ||
       value == LAUNCH_FULLSCREEN ||
@@ skipping 744 matching lines @@
     for (DictionaryValue::key_iterator i = prefs->begin_keys();
          i != prefs->end_keys(); ++i) {
       Value* value;
       if (!prefs->GetWithoutPathExpansion(*i, &value))
         continue;
       extension_pref_value_map_->SetExtensionPref(
           *ext_id, *i, kExtensionPrefsScopeIncognitoPersistent,
           value->DeepCopy());
     }
 
+    // Set content settings.
     const DictionaryValue* extension_prefs = GetExtensionPref(*ext_id);
     DCHECK(extension_prefs);
     ListValue* content_settings = NULL;
     if (extension_prefs->GetList(kPrefContentSettings,
                                  &content_settings)) {
       content_settings_store_->SetExtensionContentSettingsFromList(
           *ext_id, content_settings,
           kExtensionPrefsScopeRegular);
     }
     if (extension_prefs->GetList(kPrefIncognitoContentSettings,
@@ skipping 116 matching lines @@
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kWebStoreLogin,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }