Broke ContentSettingBubbleModelTest.Plugins on Android.

chrome/browser/plugins/chrome_plugin_service_filter.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/plugins/chrome_plugin_service_filter.h"
 
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/plugins/plugin_metadata.h"
 #include "chrome/browser/plugins/plugin_prefs.h"
@@ skipping 26 matching lines @@
     const void* context) {
   base::AutoLock lock(lock_);
   resource_context_map_.erase(context);
 }
 
 void ChromePluginServiceFilter::OverridePluginForTab(
     int render_process_id,
     int render_view_id,
     const GURL& url,
     const webkit::WebPluginInfo& plugin) {
-  base::AutoLock auto_lock(lock_);
-  ProcessDetails* details = GetOrRegisterProcess(render_process_id);
   OverriddenPlugin overridden_plugin;
+  overridden_plugin.render_process_id = render_process_id;
   overridden_plugin.render_view_id = render_view_id;
   overridden_plugin.url = url;
   overridden_plugin.plugin = plugin;
-  details->overridden_plugins.push_back(overridden_plugin);
+  base::AutoLock auto_lock(lock_);
+  overridden_plugins_.push_back(overridden_plugin);
 }
 
 void ChromePluginServiceFilter::RestrictPluginToProfileAndOrigin(
     const FilePath& plugin_path,
     Profile* profile,
     const GURL& origin) {
   base::AutoLock auto_lock(lock_);
   restricted_plugins_[plugin_path] =
       std::make_pair(PluginPrefs::GetForProfile(profile),
                      origin);
 }
 
 void ChromePluginServiceFilter::UnrestrictPlugin(
     const FilePath& plugin_path) {
   base::AutoLock auto_lock(lock_);
   restricted_plugins_.erase(plugin_path);
 }
 
-bool ChromePluginServiceFilter::IsPluginEnabled(
+bool ChromePluginServiceFilter::ShouldUsePlugin(
     int render_process_id,
     int render_view_id,
     const void* context,
     const GURL& url,
     const GURL& policy_url,
     webkit::WebPluginInfo* plugin) {
   base::AutoLock auto_lock(lock_);
-  const ProcessDetails* details = GetProcess(render_process_id);
+  // Check whether the plugin is overridden.
+  for (size_t i = 0; i < overridden_plugins_.size(); ++i) {
+    if (overridden_plugins_[i].render_process_id == render_process_id &&
+        overridden_plugins_[i].render_view_id == render_view_id &&
+        (overridden_plugins_[i].url == url ||
+         overridden_plugins_[i].url.is_empty())) {
 
-  // Check whether the plugin is overridden.
-  if (details) {
-    for (size_t i = 0; i < details->overridden_plugins.size(); ++i) {
-      if (details->overridden_plugins[i].render_view_id == render_view_id &&
-          (details->overridden_plugins[i].url == url ||
-           details->overridden_plugins[i].url.is_empty())) {
-
-        bool use = details->overridden_plugins[i].plugin.path == plugin->path;
-        if (!use)
-          return false;
-        *plugin = details->overridden_plugins[i].plugin;
-        break;
-      }
+      bool use = overridden_plugins_[i].plugin.path == plugin->path;
+      if (use)
+        *plugin = overridden_plugins_[i].plugin;
+      return use;
     }
   }
 
   // Check whether the plugin is disabled.
   ResourceContextMap::iterator prefs_it =
       resource_context_map_.find(context);
   if (prefs_it == resource_context_map_.end())
     return false;
 
   PluginPrefs* plugin_prefs = prefs_it->second.get();
@@ skipping 11 matching lines @@
         (policy_url.scheme() != origin.scheme() ||
          policy_url.host() != origin.host() ||
          policy_url.port() != origin.port())) {
       return false;
     }
   }
 
   return true;
 }
 
-bool ChromePluginServiceFilter::CanLoadPlugin(int render_process_id,
-                                              const FilePath& path) {
-  // The browser itself sometimes loads plug-ins to e.g. clear plug-in data.
-  // We always grant the browser permission.
-  if (!render_process_id)
-    return true;
-
-  base::AutoLock auto_lock(lock_);
-  const ProcessDetails* details = GetProcess(render_process_id);
-  if (!details)
-    return false;
-
-  if (details->authorized_plugins.find(path) ==
-          details->authorized_plugins.end() &&
-      details->authorized_plugins.find(FilePath()) ==
-          details->authorized_plugins.end()) {
-    return false;
-  }
-
-  return true;
-}
-
-void ChromePluginServiceFilter::AuthorizePlugin(int render_process_id,
-                                                const FilePath& plugin_path) {
-  base::AutoLock auto_lock(lock_);
-  ProcessDetails* details = GetOrRegisterProcess(render_process_id);
-  details->authorized_plugins.insert(plugin_path);
-}
-
-void ChromePluginServiceFilter::AuthorizeAllPlugins(int render_process_id) {
-  AuthorizePlugin(render_process_id, FilePath());
-}
-
 ChromePluginServiceFilter::ChromePluginServiceFilter() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_PLUGIN_ENABLE_STATUS_CHANGED,
                  content::NotificationService::AllSources());
 }
 
 ChromePluginServiceFilter::~ChromePluginServiceFilter() {
 }
 
 void ChromePluginServiceFilter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
       int render_process_id =
           content::Source<content::RenderProcessHost>(source).ptr()->GetID();
 
       base::AutoLock auto_lock(lock_);
-      plugin_details_.erase(render_process_id);
+      for (size_t i = 0; i < overridden_plugins_.size(); ++i) {
+        if (overridden_plugins_[i].render_process_id == render_process_id) {
+          overridden_plugins_.erase(overridden_plugins_.begin() + i);
+          break;
+        }
+      }
       break;
     }
     case chrome::NOTIFICATION_PLUGIN_ENABLE_STATUS_CHANGED: {
       Profile* profile = content::Source<Profile>(source).ptr();
       PluginService::GetInstance()->PurgePluginListCache(profile, false);
       if (profile && profile->HasOffTheRecordProfile()) {
         PluginService::GetInstance()->PurgePluginListCache(
             profile->GetOffTheRecordProfile(), false);
       }
       break;
     }
     default: {
       NOTREACHED();
     }
   }
 }
-
-ChromePluginServiceFilter::ProcessDetails*
-ChromePluginServiceFilter::GetOrRegisterProcess(
-    int render_process_id) {
-  return &plugin_details_[render_process_id];
-}
-
-const ChromePluginServiceFilter::ProcessDetails*
-ChromePluginServiceFilter::GetProcess(
-    int render_process_id) const {
-  std::map<int, ProcessDetails>::const_iterator it =
-      plugin_details_.find(render_process_id);
-  if (it == plugin_details_.end())
-    return NULL;
-  return &it->second;
-}
-
-ChromePluginServiceFilter::OverriddenPlugin::OverriddenPlugin()
-    : render_view_id(MSG_ROUTING_NONE) {
-}
-
-ChromePluginServiceFilter::OverriddenPlugin::~OverriddenPlugin() {
-}
-
-ChromePluginServiceFilter::ProcessDetails::ProcessDetails() {
-}
-
-ChromePluginServiceFilter::ProcessDetails::~ProcessDetails() {
-}
-