Moved some functions off ExtensionService into a new file extension_util.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2013 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 <iterator>
 #include <set>
 
@@ skipping 32 matching lines @@
 #include "chrome/browser/extensions/extension_disabled_ui.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_error_ui.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/external_install_ui.h"
 #include "chrome/browser/extensions/external_provider_impl.h"
 #include "chrome/browser/extensions/external_provider_interface.h"
 #include "chrome/browser/extensions/installed_loader.h"
 #include "chrome/browser/extensions/management_policy.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/update_observer.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
@@ skipping 214 matching lines @@
 
 const Extension* ExtensionService::GetInstalledApp(const GURL& url) const {
   const Extension* extension = extensions_.GetExtensionOrAppByURL(url);
   return (extension && extension->is_app()) ? extension : NULL;
 }
 
 bool ExtensionService::IsInstalledApp(const GURL& url) const {
   return !!GetInstalledApp(url);
 }
 
-const Extension* ExtensionService::GetIsolatedAppForRenderer(
-    int renderer_child_id) const {
-  std::set<std::string> extension_ids =
-      process_map_.GetExtensionsInProcess(renderer_child_id);
-  // All apps in one process share the same partition.
-  // It is only possible for the app to have isolated storage
-  // if there is only 1 app in the process.
-  if (extension_ids.size() != 1)
-    return NULL;
-
-  const extensions::Extension* extension =
-      extensions_.GetByID(*(extension_ids.begin()));
-  // We still need to check if the extension has isolated storage,
-  // because it's common for there to be one extension in a process
-  // without isolated storage.
-  if (extension &&
-      extensions::AppIsolationInfo::HasIsolatedStorage(extension))
-    return extension;
-
-  return NULL;
-}
-
 // static
 // This function is used to implement the command-line switch
 // --uninstall-extension, and to uninstall an extension via sync.  The LOG
 // statements within this function are used to inform the user if the uninstall
 // cannot be done.
 bool ExtensionService::UninstallExtensionHelper(
     ExtensionService* extensions_service,
     const std::string& extension_id) {
   // We can't call UninstallExtension with an invalid extension ID.
   if (!extensions_service->GetInstalledExtension(extension_id)) {
@@ skipping 924 matching lines @@
 }
 
 Profile* ExtensionService::profile() {
   return profile_;
 }
 
 extensions::ExtensionPrefs* ExtensionService::extension_prefs() {
   return extension_prefs_;
 }
 
+const extensions::ExtensionPrefs* ExtensionService::extension_prefs() const {
+  return extension_prefs_;
+}
+
 extensions::SettingsFrontend* ExtensionService::settings_frontend() {
   return settings_frontend_.get();
 }
 
 extensions::ContentSettingsStore* ExtensionService::GetContentSettingsStore() {
   return extension_prefs()->content_settings_store();
 }
 
 bool ExtensionService::is_ready() {
   return ready_->is_signaled();
@@ skipping 145 matching lines @@
     }
   }
 
   extension_prefs()->extension_sorting()->FixNTPOrdinalCollisions();
 
   return syncer::SyncError();
 }
 
 extensions::ExtensionSyncData ExtensionService::GetExtensionSyncData(
     const Extension& extension) const {
-  return extensions::ExtensionSyncData(extension,
-                                       IsExtensionEnabled(extension.id()),
-                                       IsIncognitoEnabled(extension.id()));
+  return extensions::ExtensionSyncData(
+      extension,
+      IsExtensionEnabled(extension.id()),
+      extension_util::IsIncognitoEnabled(extension.id(), this));
 }
 
 extensions::AppSyncData ExtensionService::GetAppSyncData(
     const Extension& extension) const {
   return extensions::AppSyncData(
       extension,
       IsExtensionEnabled(extension.id()),
-      IsIncognitoEnabled(extension.id()),
+      extension_util::IsIncognitoEnabled(extension.id(), this),
       extension_prefs_->extension_sorting()->GetAppLaunchOrdinal(
           extension.id()),
       extension_prefs_->extension_sorting()->GetPageOrdinal(extension.id()));
 }
 
 std::vector<extensions::ExtensionSyncData>
   ExtensionService::GetExtensionSyncDataList() const {
   std::vector<extensions::ExtensionSyncData> extension_sync_list;
   extension_sync_bundle_.GetExtensionSyncDataListHelper(extensions_,
                                                         &extension_sync_list);
@@ skipping 124 matching lines @@
     EnableExtension(id);
   else if (!IsPendingEnable(id))
     DisableExtension(id, Extension::DISABLE_UNKNOWN_FROM_SYNC);
 
   // We need to cache some version information here because setting the
   // incognito flag invalidates the |extension| pointer (it reloads the
   // extension).
   bool extension_installed = (extension != NULL);
   int result = extension ?
       extension->version()->CompareTo(extension_sync_data.version()) : 0;
-  SetIsIncognitoEnabled(id, extension_sync_data.incognito_enabled());
+  extension_util::SetIsIncognitoEnabled(
+      id, this, extension_sync_data.incognito_enabled());
   extension = NULL;  // No longer safe to use.
 
   if (extension_installed) {
     // If the extension is already installed, check if it's outdated.
     if (result < 0) {
       // Extension is outdated.
       return false;
     }
   } else {
     // TODO(akalin): Replace silent update with a list of enabled
@@ skipping 16 matching lines @@
       // never be removed (we'll never install a syncable version of the
       // extension), so that GetAllSyncData() continues to send it.
     }
     // Track pending extensions so that we can return them in GetAllSyncData().
     return false;
   }
 
   return true;
 }
 
-bool ExtensionService::IsIncognitoEnabled(
-    const std::string& extension_id) const {
-  const Extension* extension = GetInstalledExtension(extension_id);
-  if (extension && !extension->can_be_incognito_enabled())
-    return false;
-  // If this is an existing component extension we always allow it to
-  // work in incognito mode.
-  if (extension && extension->location() == Manifest::COMPONENT)
-    return true;
-  if (extension && extension->force_incognito_enabled())
-    return true;
-
-  // Check the prefs.
-  return extension_prefs_->IsIncognitoEnabled(extension_id);
-}
-
-void ExtensionService::SetIsIncognitoEnabled(
-    const std::string& extension_id, bool enabled) {
-  const Extension* extension = GetInstalledExtension(extension_id);
-  if (extension && !extension->can_be_incognito_enabled())
-    return;
-  if (extension && extension->location() == Manifest::COMPONENT) {
-    // This shouldn't be called for component extensions unless they are
-    // syncable.
-    DCHECK(extensions::sync_helper::IsSyncable(extension));
-
-    // If we are here, make sure the we aren't trying to change the value.
-    DCHECK_EQ(enabled, IsIncognitoEnabled(extension_id));
-
-    return;
-  }
-
-  // Broadcast unloaded and loaded events to update browser state. Only bother
-  // if the value changed and the extension is actually enabled, since there is
-  // no UI otherwise.
-  bool old_enabled = extension_prefs_->IsIncognitoEnabled(extension_id);
-  if (enabled == old_enabled)
-    return;
-
-  extension_prefs_->SetIsIncognitoEnabled(extension_id, enabled);
-
-  bool extension_is_enabled = extensions_.Contains(extension_id);
-
-  // When we reload the extension the ID may be invalidated if we've passed it
-  // by const ref everywhere. Make a copy to be safe.
-  std::string id = extension_id;
-  if (extension_is_enabled)
-    ReloadExtension(id);
-
-  // Reloading the extension invalidates the |extension| pointer.
-  extension = GetInstalledExtension(id);
-  if (extension)
-    SyncExtensionChangeIfNeeded(*extension);
-}
-
-bool ExtensionService::CanCrossIncognito(const Extension* extension) const {
-  // We allow the extension to see events and data from another profile iff it
-  // uses "spanning" behavior and it has incognito access. "split" mode
-  // extensions only see events for a matching profile.
-  CHECK(extension);
-  return IsIncognitoEnabled(extension->id()) &&
-         !extensions::IncognitoInfo::IsSplitMode(extension);
-}
-
-bool ExtensionService::CanLoadInIncognito(const Extension* extension) const {
-  if (extension->is_hosted_app())
-    return true;
-  // Packaged apps and regular extensions need to be enabled specifically for
-  // incognito (and split mode should be set).
-  return extensions::IncognitoInfo::IsSplitMode(extension) &&
-         IsIncognitoEnabled(extension->id());
-}
-
 void ExtensionService::OnExtensionMoved(
     const std::string& moved_extension_id,
     const std::string& predecessor_extension_id,
     const std::string& successor_extension_id) {
   extension_prefs_->extension_sorting()->OnExtensionMoved(
       moved_extension_id,
       predecessor_extension_id,
       successor_extension_id);
 
   const Extension* extension = GetInstalledExtension(moved_extension_id);
   if (extension)
     SyncExtensionChangeIfNeeded(*extension);
 }
 
-bool ExtensionService::AllowFileAccess(const Extension* extension) const {
-  return (CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kDisableExtensionsFileAccessCheck) ||
-          extension_prefs_->AllowFileAccess(extension->id()));
-}
-
-void ExtensionService::SetAllowFileAccess(const Extension* extension,
-                                          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);
-
-  bool extension_is_enabled = extensions_.Contains(extension->id());
-  if (extension_is_enabled)
-    ReloadExtension(extension->id());
-}
-
 // Some extensions will autoupdate themselves externally from Chrome.  These
 // are typically part of some larger client application package.  To support
 // these, the extension will register its location in the the preferences file
 // (and also, on Windows, in the registry) and this code will periodically
 // check that location for a .crx file, which it will then install locally if
 // a new version is available.
 // Errors are reported through ExtensionErrorReporter. Succcess is not
 // reported.
 void ExtensionService::CheckForExternalUpdates() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 1494 matching lines @@
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }