Cleanup: Constify more ExtensionService methods, and IWYU.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2012 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 88 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/pepper_plugin_info.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
-#include "ui/base/l10n/l10n_util.h"
 #include "webkit/database/database_tracker.h"
 #include "webkit/database/database_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/extensions/bluetooth_event_router.h"
 #include "chrome/browser/chromeos/extensions/file_browser_event_router.h"
 #include "chrome/browser/chromeos/extensions/input_method_event_router.h"
 #include "chrome/browser/chromeos/extensions/media_player_event_router.h"
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
 #include "chrome/browser/extensions/api/input_ime/input_ime_api.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #endif
 
-using base::Time;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::DevToolsAgentHostRegistry;
 using content::PluginService;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionIdSet;
 using extensions::ExtensionInfo;
 using extensions::UnloadedExtensionInfo;
@@ skipping 118 matching lines @@
   // source.  In this case, signal that this extension will not be
   // installed by returning false.
   if (!pending_extension_manager()->AddFromExternalUpdateUrl(
           id, update_url, location))
     return false;
 
   update_once_all_providers_are_ready_ = true;
   return true;
 }
 
-const Extension* ExtensionService::GetInstalledApp(const GURL& url) {
+const Extension* ExtensionService::GetInstalledApp(const GURL& url) const {
   const Extension* extension = extensions_.GetExtensionOrAppByURL(
       ExtensionURLInfo(url));
-  if (extension && extension->is_app())
-    return extension;
-
-  return NULL;
+  return (extension && extension->is_app()) ? extension : NULL;
 }
 
-bool ExtensionService::IsInstalledApp(const GURL& url) {
+bool ExtensionService::IsInstalledApp(const GURL& url) const {
   return !!GetInstalledApp(url);
 }
 
 void ExtensionService::SetInstalledAppForRenderer(int renderer_child_id,
                                                   const Extension* app) {
   installed_app_hosts_[renderer_child_id] = app;
 }
 
 const Extension* ExtensionService::GetInstalledAppForRenderer(
-    int renderer_child_id) {
-  InstalledAppMap::iterator i = installed_app_hosts_.find(renderer_child_id);
-  if (i == installed_app_hosts_.end())
-    return NULL;
-  return i->second;
+    int renderer_child_id) const {
+  InstalledAppMap::const_iterator i =
+      installed_app_hosts_.find(renderer_child_id);
+  return i == installed_app_hosts_.end() ? NULL : i->second;
 }
 
 // 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) {
@@ skipping 504 matching lines @@
   std::set<ExtensionWarningSet::WarningType> warnings;
   extension_warnings_.GetWarningsAffectingExtension(extension_id, &warnings);
   extension_warnings_.ClearWarnings(warnings);
 
   return true;
 }
 
 bool ExtensionService::IsExtensionEnabled(
     const std::string& extension_id) const {
   if (extensions_.Contains(extension_id) ||
-      terminated_extensions_.Contains(extension_id))
+      terminated_extensions_.Contains(extension_id)) {
     return true;
+  }
 
   if (disabled_extensions_.Contains(extension_id))
     return false;
 
   // If the extension hasn't been loaded yet, check the prefs for it. Assume
   // enabled unless otherwise noted.
   return !extension_prefs_->IsExtensionDisabled(extension_id) &&
       !extension_prefs_->IsExternalExtensionUninstalled(extension_id);
 }
 
@@ skipping 753 matching lines @@
     return;
   }
   if (value)
     UMA_HISTOGRAM_COUNTS("Apps.SetAppNotificationsDisabled", 1);
   else
     UMA_HISTOGRAM_COUNTS("Apps.SetAppNotificationsEnabled", 1);
   extension_prefs_->SetAppNotificationDisabled(extension_id, value);
   SyncExtensionChangeIfNeeded(*extension);
 }
 
-bool ExtensionService::CanCrossIncognito(const Extension* 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()) &&
       !extension->incognito_split_mode();
 }
 
 bool ExtensionService::CanLoadInIncognito(const Extension* extension) const {
   if (extension->is_hosted_app())
@@ skipping 11 matching lines @@
   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) {
+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);
@@ skipping 828 matching lines @@
   ExtensionIdSet result;
   for (ExtensionSet::const_iterator it = extensions_.begin();
        it != extensions_.end(); ++it) {
     if ((*it)->is_app() && (*it)->location() != Extension::COMPONENT)
       result.insert((*it)->id());
   }
 
   return result;
 }
 
-bool ExtensionService::IsBackgroundPageReady(const Extension* extension) {
-  return (!extension->has_persistent_background_page() ||
-          extension_runtime_data_[extension->id()].background_page_ready);
+bool ExtensionService::IsBackgroundPageReady(const Extension* extension) const {
+  if (!extension->has_persistent_background_page())
+    return true;
+  ExtensionRuntimeDataMap::const_iterator it =
+      extension_runtime_data_.find(extension->id());
+  return it == extension_runtime_data_.end() ? false :
+                                               it->second.background_page_ready;
 }
 
 void ExtensionService::SetBackgroundPageReady(const Extension* extension) {
   DCHECK(extension->has_background_page());
   extension_runtime_data_[extension->id()].background_page_ready = true;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_BACKGROUND_PAGE_READY,
       content::Source<const Extension>(extension),
       content::NotificationService::NoDetails());
 }
 
-bool ExtensionService::IsBeingUpgraded(const Extension* extension) {
-  return extension_runtime_data_[extension->id()].being_upgraded;
+bool ExtensionService::IsBeingUpgraded(const Extension* extension) const {
+  ExtensionRuntimeDataMap::const_iterator it =
+      extension_runtime_data_.find(extension->id());
+  return it == extension_runtime_data_.end() ? false :
+                                               it->second.being_upgraded;
 }
 
 void ExtensionService::SetBeingUpgraded(const Extension* extension,
                                          bool value) {
   extension_runtime_data_[extension->id()].being_upgraded = value;
 }
 
-bool ExtensionService::HasUsedWebRequest(const Extension* extension) {
-  return extension_runtime_data_[extension->id()].has_used_webrequest;
+bool ExtensionService::HasUsedWebRequest(const Extension* extension) const {
+  ExtensionRuntimeDataMap::const_iterator it =
+      extension_runtime_data_.find(extension->id());
+  return it == extension_runtime_data_.end() ? false :
+                                               it->second.has_used_webrequest;
 }
 
 void ExtensionService::SetHasUsedWebRequest(const Extension* extension,
                                             bool value) {
   extension_runtime_data_[extension->id()].has_used_webrequest = value;
 }
 
 base::PropertyBag* ExtensionService::GetPropertyBag(
     const Extension* extension) {
   return &extension_runtime_data_[extension->id()].property_bag;
@@ skipping 65 matching lines @@
 
 ExtensionService::NaClModuleInfoList::iterator
     ExtensionService::FindNaClModule(const GURL& url) {
   for (NaClModuleInfoList::iterator iter = nacl_module_list_.begin();
        iter != nacl_module_list_.end(); ++iter) {
     if (iter->url == url)
       return iter;
   }
   return nacl_module_list_.end();
 }