Make <all_urls> and file:///* in permissions trigger "Allow file access"

chrome/browser/extensions/extension_service.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_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 181 matching lines @@
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   frontend_ = frontend;
 
   // Explicit UI loads are always noisy.
   alert_on_error_ = true;
 
   FilePath extension_path = path_in;
   file_util::AbsolutePath(&extension_path);
 
-  int flags = Extension::NO_FLAGS;
+  int flags = Extension::ShouldAlwaysAllowFileAccess(Extension::LOAD) ?
+      Extension::ALLOW_FILE_ACCESS : Extension::NO_FLAGS;
   if (Extension::ShouldDoStrictErrorChecking(Extension::LOAD))
     flags |= Extension::STRICT_ERROR_CHECKS;
   std::string error;
   scoped_refptr<const Extension> extension(extension_file_util::LoadExtension(
       extension_path,
       Extension::LOAD,
       flags,
       &error));
 
   if (!extension) {
@@ skipping 578 matching lines @@
       // UI thread because reloads should be very rare, and the complexity
       // added by delaying the time when the extensions service knows about
       // all extensions is significant.  See crbug.com/37548 for details.
       // |allow_io| disables tests that file operations run on the file
       // thread.
       base::ThreadRestrictions::ScopedAllowIO allow_io;
 
       int flags = Extension::NO_FLAGS;
       if (Extension::ShouldDoStrictErrorChecking(info->extension_location))
         flags |= Extension::STRICT_ERROR_CHECKS;
+      if (extension_prefs_->AllowFileAccess(info->extension_id))
+        flags |= Extension::ALLOW_FILE_ACCESS;
       std::string error;
       scoped_refptr<const Extension> extension(
           extension_file_util::LoadExtension(
               info->extension_path,
               info->extension_location,
               flags,
               &error));
 
       if (extension.get()) {
         extensions_info->at(i)->extension_manifest.reset(
@@ skipping 104 matching lines @@
   std::string error;
   scoped_refptr<const Extension> extension(NULL);
   if (!extension_prefs_->IsExtensionAllowedByPolicy(info.extension_id)) {
     error = errors::kDisabledByPolicy;
   } else if (info.extension_manifest.get()) {
     int flags = Extension::NO_FLAGS;
     if (info.extension_location != Extension::LOAD)
       flags |= Extension::REQUIRE_KEY;
     if (Extension::ShouldDoStrictErrorChecking(info.extension_location))
       flags |= Extension::STRICT_ERROR_CHECKS;
+    if (extension_prefs_->AllowFileAccess(info.extension_id))
+      flags |= Extension::ALLOW_FILE_ACCESS;
     extension = Extension::Create(
         info.extension_path,
         info.extension_location,
         *info.extension_manifest,
         flags,
         &error);
   } else {
     error = errors::kManifestUnreadable;
   }
 
@@ skipping 147 matching lines @@
   return IsIncognitoEnabled(extension) && !extension->incognito_split_mode();
 }
 
 bool ExtensionService::AllowFileAccess(const Extension* extension) {
   return (CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisableExtensionsFileAccessCheck) ||
           extension_prefs_->AllowFileAccess(extension->id()));
 }
 
 void ExtensionService::SetAllowFileAccess(const Extension* extension,
-                                           bool allow) {
+                                          bool allow) {
+  // Reload to update browser state. Only bother if the value changed and the
+  // extension is actually enabled, since there is no UI otherwise.
+  bool old_allow = AllowFileAccess(extension);
+  if (allow == old_allow)
+    return;
+
   extension_prefs_->SetAllowFileAccess(extension->id(), allow);
-  NotificationService::current()->Notify(
-      NotificationType::EXTENSION_USER_SCRIPTS_UPDATED,
-      Source<Profile>(profile_),
-      Details<const Extension>(extension));
+
+  bool extension_is_enabled = std::find(extensions_.begin(), extensions_.end(),
+                                        extension) != extensions_.end();
+  if (extension_is_enabled)
+    ReloadExtension(extension->id());
 }
 
 bool ExtensionService::GetBrowserActionVisibility(const Extension* extension) {
   return extension_prefs_->GetBrowserActionVisibility(extension);
 }
 
 void ExtensionService::SetBrowserActionVisibility(const Extension* extension,
                                                   bool visible) {
   extension_prefs_->SetBrowserActionVisibility(extension, visible);
 }
@@ skipping 379 matching lines @@
     initial_enable_incognito =
         extension_prefs_->IsIncognitoEnabled(extension->id());
   }
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.InstallType",
                             extension->GetType(), 100);
   ShownSectionsHandler::OnExtensionInstalled(profile_->GetPrefs(), extension);
   extension_prefs_->OnExtensionInstalled(
       extension, initial_state, initial_enable_incognito);
 
-  // Unpacked extensions start off with file access since they are a developer
-  // feature.
-  if (extension->location() == Extension::LOAD)
+  // Unpacked extensions default to allowing file access, but if that has been
+  // overridden, don't reset the value.
+  if (Extension::ShouldAlwaysAllowFileAccess(Extension::LOAD) &&
+      !extension_prefs_->HasAllowFileAccessSetting(extension->id())) {
     extension_prefs_->SetAllowFileAccess(extension->id(), true);
+  }
 
   // If the extension is a theme, tell the profile (and therefore ThemeProvider)
   // to apply it.
   if (extension->is_theme()) {
     NotificationService::current()->Notify(
         NotificationType::THEME_INSTALLED,
         Source<Profile>(profile_),
         Details<const Extension>(extension));
   } else {
     NotificationService::current()->Notify(
@@ skipping 253 matching lines @@
 }
 
 void ExtensionService::SetBeingUpgraded(const Extension* extension,
                                          bool value) {
   extension_runtime_data_[extension->id()].being_upgraded = value;
 }
 
 PropertyBag* ExtensionService::GetPropertyBag(const Extension* extension) {
   return &extension_runtime_data_[extension->id()].property_bag;
 }