Move parsing of NaCl modules out of Extension.

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 111 matching lines @@
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::PluginService;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionIdSet;
 using extensions::ExtensionInfo;
 using extensions::FeatureSwitch;
 using extensions::Manifest;
+using extensions::NaClModuleInfo;
 using extensions::PermissionMessage;
 using extensions::PermissionMessages;
 using extensions::PermissionSet;
 using extensions::UnloadedExtensionInfo;
 
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 // Histogram values for logging events related to externally installed
@@ skipping 29 matching lines @@
 
 ExtensionService::ExtensionRuntimeData::ExtensionRuntimeData()
     : background_page_ready(false),
       being_upgraded(false),
       has_used_webrequest(false) {
 }
 
 ExtensionService::ExtensionRuntimeData::~ExtensionRuntimeData() {
 }
 
-ExtensionService::NaClModuleInfo::NaClModuleInfo() {
-}
-
-ExtensionService::NaClModuleInfo::~NaClModuleInfo() {
-}
-
 // ExtensionService.
 
 const char ExtensionService::kLocalAppSettingsDirectoryName[] =
     "Local App Settings";
 const char ExtensionService::kLocalExtensionSettingsDirectoryName[] =
     "Local Extension Settings";
 const char ExtensionService::kSyncAppSettingsDirectoryName[] =
     "Sync App Settings";
 const char ExtensionService::kSyncExtensionSettingsDirectoryName[] =
     "Sync Extension Settings";
@@ skipping 889 matching lines @@
 
   // Same for chrome://thumb/ resources.
   if (extensions::PermissionsData::HasHostPermission(
           extension, GURL(chrome::kChromeUIThumbnailURL))) {
     ThumbnailSource* thumbnail_source = new ThumbnailSource(profile_);
     content::URLDataSource::Add(profile_, thumbnail_source);
   }
 
 #if defined(ENABLE_PLUGINS)
   // TODO(mpcomplete): This ends up affecting all profiles. See crbug.com/80757.
-  bool plugins_changed = false;
+  bool plugins_or_nacl_changed = false;

[not at google - send to devlin, 2013/05/29 16:29:21]

Without picking through the source code of all of this: is it possible/feasible
to move the nacl module stuff out of ExtensionService entirely and into its own
service that hangs of ExtensionSystem? At brief perusal it looks like it
basically listens to LOAD and UNLOAD of extensions. It would be a really nice
cleanup to move that stuff out.

[not at google - send to devlin, 2013/05/29 16:32:09]

s/ExtensionSystem/a PKS/g

[Yoyo Zhou, 2013/05/29 22:27:47]

Yeah, it's definitely possible; it was all dumped into here 2 years ago. I moved
it all out to PluginManager. How's it look?

   if (extensions::PluginInfo::HasPlugins(extension)) {
     const extensions::PluginInfo::PluginVector* plugins =
       extensions::PluginInfo::GetPlugins(extension);
     CHECK(plugins);
-    plugins_changed = true;
+    plugins_or_nacl_changed = true;
     for (extensions::PluginInfo::PluginVector::const_iterator plugin =
              plugins->begin();
          plugin != plugins->end(); ++plugin) {
       PluginService::GetInstance()->RefreshPlugins();
       PluginService::GetInstance()->AddExtraPluginPath(plugin->path);
       ChromePluginServiceFilter* filter =
           ChromePluginServiceFilter::GetInstance();
       if (plugin->is_public) {
         filter->RestrictPluginToProfileAndOrigin(
             plugin->path, profile_, GURL());
       } else {
         filter->RestrictPluginToProfileAndOrigin(
             plugin->path, profile_, extension->url());
       }
     }
   }
 
-  bool nacl_modules_changed = false;
-  for (size_t i = 0; i < extension->nacl_modules().size(); ++i) {
-    const Extension::NaClModuleInfo& module = extension->nacl_modules()[i];
-    RegisterNaClModule(module.url, module.mime_type);
-    nacl_modules_changed = true;
+  const NaClModuleInfo::List* nacl_modules =
+      NaClModuleInfo::GetNaClModules(extension);
+  if (nacl_modules) {
+    plugins_or_nacl_changed = true;
+    for (NaClModuleInfo::List::const_iterator module = nacl_modules->begin();
+         module != nacl_modules->end(); ++module) {
+      RegisterNaClModule(*module);
+    }
+    UpdatePluginListWithNaClModules();
   }
 
-  if (nacl_modules_changed)
-    UpdatePluginListWithNaClModules();
-
-  if (plugins_changed || nacl_modules_changed)
+  if (plugins_or_nacl_changed)
     PluginService::GetInstance()->PurgePluginListCache(profile_, false);
 #endif  // defined(ENABLE_PLUGINS)
 }
 
 void ExtensionService::NotifyExtensionUnloaded(
     const Extension* extension,
     extension_misc::UnloadedExtensionReason reason) {
   UnloadedExtensionInfo details(extension, reason);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_UNLOADED,
@@ skipping 35 matching lines @@
           GetFileSystemContext();
   if (filesystem_context && filesystem_context->external_provider()) {
     filesystem_context->external_provider()->
         RevokeAccessForExtension(extension->id());
   }
 #endif
 
   UpdateActiveExtensionsInCrashReporter();
 
 #if defined(ENABLE_PLUGINS)
-  bool plugins_changed = false;
+  bool plugins_or_nacl_changed = false;
   if (extensions::PluginInfo::HasPlugins(extension)) {
     const extensions::PluginInfo::PluginVector* plugins =
       extensions::PluginInfo::GetPlugins(extension);
-    plugins_changed = true;
+    plugins_or_nacl_changed = true;
     for (extensions::PluginInfo::PluginVector::const_iterator plugin =
              plugins->begin();
          plugin != plugins->end(); ++plugin) {
       PluginService::GetInstance()->ForcePluginShutdown(plugin->path);
       PluginService::GetInstance()->RefreshPlugins();
       PluginService::GetInstance()->RemoveExtraPluginPath(plugin->path);
       ChromePluginServiceFilter::GetInstance()->UnrestrictPlugin(plugin->path);
     }
   }
 
-  bool nacl_modules_changed = false;
-  for (size_t i = 0; i < extension->nacl_modules().size(); ++i) {
-    const Extension::NaClModuleInfo& module = extension->nacl_modules()[i];
-    UnregisterNaClModule(module.url);
-    nacl_modules_changed = true;
+  const NaClModuleInfo::List* nacl_modules =
+      NaClModuleInfo::GetNaClModules(extension);
+  if (nacl_modules) {
+    plugins_or_nacl_changed = true;
+    for (NaClModuleInfo::List::const_iterator module = nacl_modules->begin();
+         module != nacl_modules->end(); ++module) {
+      UnregisterNaClModule(*module);
+    }
+    UpdatePluginListWithNaClModules();
   }
 
-  if (nacl_modules_changed)
-    UpdatePluginListWithNaClModules();
-
-  if (plugins_changed || nacl_modules_changed)
+  if (plugins_or_nacl_changed)
     PluginService::GetInstance()->PurgePluginListCache(profile_, false);
 #endif  // defined(ENABLE_PLUGINS)
 }
 
 Profile* ExtensionService::profile() {
   return profile_;
 }
 
 extensions::ExtensionPrefs* ExtensionService::extension_prefs() {
   return extension_prefs_;
@@ skipping 1592 matching lines @@
       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;
 }
 
-void ExtensionService::RegisterNaClModule(const GURL& url,
-                                          const std::string& mime_type) {
-  NaClModuleInfo info;
-  info.url = url;
-  info.mime_type = mime_type;
-
-  DCHECK(FindNaClModule(url) == nacl_module_list_.end());
+void ExtensionService::RegisterNaClModule(const NaClModuleInfo& info) {
+  DCHECK(FindNaClModule(info.url) == nacl_module_list_.end());
   nacl_module_list_.push_front(info);
 }
 
-void ExtensionService::UnregisterNaClModule(const GURL& url) {
-  NaClModuleInfoList::iterator iter = FindNaClModule(url);
+void ExtensionService::UnregisterNaClModule(const NaClModuleInfo& info) {
+  NaClModuleInfo::List::iterator iter = FindNaClModule(info.url);
   DCHECK(iter != nacl_module_list_.end());
   nacl_module_list_.erase(iter);
 }
 
 void ExtensionService::UpdatePluginListWithNaClModules() {
   // An extension has been added which has a nacl_module component, which means
   // there is a MIME type that module wants to handle, so we need to add that
   // MIME type to plugins which handle NaCl modules in order to allow the
   // individual modules to handle these types.
   base::FilePath path;
   if (!PathService::Get(chrome::FILE_NACL_PLUGIN, &path))
     return;
   const content::PepperPluginInfo* pepper_info =
       PluginService::GetInstance()->GetRegisteredPpapiPluginInfo(path);
   if (!pepper_info)
     return;
 
   std::vector<webkit::WebPluginMimeType>::const_iterator mime_iter;
   // Check each MIME type the plugins handle for the NaCl MIME type.
   for (mime_iter = pepper_info->mime_types.begin();
        mime_iter != pepper_info->mime_types.end(); ++mime_iter) {
     if (mime_iter->mime_type == kNaClPluginMimeType) {
       // This plugin handles "application/x-nacl".
 
       PluginService::GetInstance()->
           UnregisterInternalPlugin(pepper_info->path);
 
       webkit::WebPluginInfo info = pepper_info->ToWebPluginInfo();
 
-      for (ExtensionService::NaClModuleInfoList::const_iterator iter =
-          nacl_module_list_.begin();
-          iter != nacl_module_list_.end(); ++iter) {
+      for (NaClModuleInfo::List::const_iterator iter =
+               nacl_module_list_.begin();
+           iter != nacl_module_list_.end(); ++iter) {
         // Add the MIME type specified in the extension to this NaCl plugin,
         // With an extra "nacl" argument to specify the location of the NaCl
         // manifest file.
         webkit::WebPluginMimeType mime_type_info;
         mime_type_info.mime_type = iter->mime_type;
         mime_type_info.additional_param_names.push_back(UTF8ToUTF16("nacl"));
         mime_type_info.additional_param_values.push_back(
             UTF8ToUTF16(iter->url.spec()));
         info.mime_types.push_back(mime_type_info);
       }
 
       PluginService::GetInstance()->RefreshPlugins();
       PluginService::GetInstance()->RegisterInternalPlugin(info, true);
       // This plugin has been modified, no need to check the rest of its
       // types, but continue checking other plugins.
       break;
     }
   }
 }
 
-ExtensionService::NaClModuleInfoList::iterator
-    ExtensionService::FindNaClModule(const GURL& url) {
-  for (NaClModuleInfoList::iterator iter = nacl_module_list_.begin();
+NaClModuleInfo::List::iterator
+ExtensionService::FindNaClModule(const GURL& url) {
+  for (NaClModuleInfo::List::iterator iter = nacl_module_list_.begin();
        iter != nacl_module_list_.end(); ++iter) {
     if (iter->url == url)
       return iter;
   }
   return nacl_module_list_.end();
 }
 
 void ExtensionService::DoPostLoadTasks(const Extension* extension) {
   std::map<std::string, int>::iterator it =
       on_load_events_.find(extension->id());
@@ skipping 206 matching lines @@
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }