Take out the activex control.

chrome/browser/plugin_service.cc

 // Copyright (c) 2006-2008 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 "build/build_config.h"
 
 #include "chrome/browser/plugin_service.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
@@ skipping 98 matching lines @@
        !iter.Done(); ++iter) {
     PluginProcessHost* plugin = static_cast<PluginProcessHost*>(*iter);
     if (plugin->info().path == plugin_path)
       return plugin;
   }
 
   return NULL;
 }
 
 PluginProcessHost* PluginService::FindOrStartPluginProcess(
-    const FilePath& plugin_path,
-    const std::string& clsid) {
+    const FilePath& plugin_path) {
   DCHECK(MessageLoop::current() ==
          ChromeThread::GetMessageLoop(ChromeThread::IO));
 
   PluginProcessHost *plugin_host = FindPluginProcess(plugin_path);
   if (plugin_host)
     return plugin_host;
 
   WebPluginInfo info;
   if (!NPAPI::PluginList::Singleton()->GetPluginInfoByPath(
           plugin_path, &info)) {
     DCHECK(false);
     return NULL;
   }
 
   // This plugin isn't loaded by any plugin process, so create a new process.
   plugin_host = new PluginProcessHost();
-  if (!plugin_host->Init(info, clsid, ui_locale_)) {
+  if (!plugin_host->Init(info, ui_locale_)) {
     DCHECK(false);  // Init is not expected to fail
     delete plugin_host;
     return NULL;
   }
 
   return plugin_host;
 }
 
 void PluginService::OpenChannelToPlugin(
-    ResourceMessageFilter* renderer_msg_filter, const GURL& url,
-    const std::string& mime_type, const std::string& clsid,
-    const std::wstring& locale, IPC::Message* reply_msg) {
+    ResourceMessageFilter* renderer_msg_filter,
+    const GURL& url,
+    const std::string& mime_type,
+    const std::wstring& locale,
+    IPC::Message* reply_msg) {
   DCHECK(MessageLoop::current() ==
          ChromeThread::GetMessageLoop(ChromeThread::IO));
   // We don't need a policy URL here because that was already checked by a
   // previous call to GetPluginPath.
   GURL policy_url;
-  FilePath plugin_path = GetPluginPath(url, policy_url, mime_type, clsid, NULL);
-  PluginProcessHost* plugin_host = FindOrStartPluginProcess(plugin_path, clsid);
+  FilePath plugin_path = GetPluginPath(url, policy_url, mime_type, NULL);
+  PluginProcessHost* plugin_host = FindOrStartPluginProcess(plugin_path);
   if (plugin_host) {
     plugin_host->OpenChannelToPlugin(renderer_msg_filter, mime_type, reply_msg);
   } else {
-    PluginProcessHost::ReplyToRenderer(renderer_msg_filter,
-                                       IPC::ChannelHandle(),
-                                       WebPluginInfo(),
-                                       reply_msg);
+    PluginProcessHost::ReplyToRenderer(
+        renderer_msg_filter, IPC::ChannelHandle(), WebPluginInfo(), reply_msg);
   }
 }
 
 FilePath PluginService::GetPluginPath(const GURL& url,
                                       const GURL& policy_url,
                                       const std::string& mime_type,
-                                      const std::string& clsid,
                                       std::string* actual_mime_type) {
   bool allow_wildcard = true;
   WebPluginInfo info;
-  if (NPAPI::PluginList::Singleton()->GetPluginInfo(url, mime_type, clsid,
-                                                    allow_wildcard, &info,
-                                                    actual_mime_type) &&
+  if (NPAPI::PluginList::Singleton()->GetPluginInfo(
+          url, mime_type, allow_wildcard, &info, actual_mime_type) &&
       PluginAllowedForURL(info.path, policy_url)) {
     return info.path;
   }
 
   return FilePath();
 }
 
 void PluginService::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
 #if defined(OS_WIN)
@@ skipping 52 matching lines @@
   PrivatePluginMap::iterator it = private_plugins_.find(plugin_path);
   if (it == private_plugins_.end())
     return true;  // This plugin is not private, so it's allowed everywhere.
 
   // We do a dumb compare of scheme and host, rather than using the domain
   // service, since we only care about this for extensions.
   const GURL& required_url = it->second;
   return (url.scheme() == required_url.scheme() &&
           url.host() == required_url.host());
 }