Ensure we don't load plugins on the IO thread

chrome/browser/renderer_host/resource_dispatcher_host.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
@@ skipping 236 matching lines @@
     : ui_loop_(MessageLoop::current()),
       io_loop_(io_loop),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           download_file_manager_(new DownloadFileManager(ui_loop_, this))),
       download_request_manager_(new DownloadRequestManager(io_loop, ui_loop_)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           save_file_manager_(new SaveFileManager(ui_loop_, io_loop, this))),
       safe_browsing_(new SafeBrowsingService),
       webkit_thread_(new WebKitThread),
       request_id_(-1),
-      plugin_service_(PluginService::GetInstance()),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_runner_(this)),
       is_shutdown_(false),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       receiver_(NULL) {
 }
 
 ResourceDispatcherHost::~ResourceDispatcherHost() {
   AsyncResourceHandler::GlobalCleanup();
   STLDeleteValues(&pending_requests_);
@@ skipping 191 matching lines @@
             std::string()));
       }
     }
     return;
   }
 
   // Ensure the Chrome plugins are loaded, as they may intercept network
   // requests.  Does nothing if they are already loaded.
   // TODO(mpcomplete): This takes 200 ms!  Investigate parallelizing this by
   // starting the load earlier in a BG thread.
-  plugin_service_->LoadChromePlugins(this);
+  PluginService::GetInstance()->LoadChromePlugins(this);
 
   // Construct the event handler.
   scoped_refptr<ResourceHandler> handler;
   if (sync_result) {
     handler = new SyncResourceHandler(receiver_, request_data.url, sync_result);
   } else {
     handler = new AsyncResourceHandler(receiver_,
                                        process_id,
                                        route_id,
                                        receiver_->handle(),
@@ skipping 179 matching lines @@
   // Check if the renderer is permitted to request the requested URL.
   if (!ChildProcessSecurityPolicy::GetInstance()->
           CanRequestURL(process_id, url)) {
     LOG(INFO) << "Denied unauthorized download request for " <<
         url.possibly_invalid_spec();
     return;
   }
 
   // Ensure the Chrome plugins are loaded, as they may intercept network
   // requests.  Does nothing if they are already loaded.
-  plugin_service_->LoadChromePlugins(this);
+  PluginService::GetInstance()->LoadChromePlugins(this);
   URLRequest* request = new URLRequest(url, this);
 
   request_id_--;
 
   scoped_refptr<ResourceHandler> handler =
       new DownloadResourceHandler(this,
                                   process_id,
                                   route_id,
                                   request_id_,
                                   url,
@@ skipping 45 matching lines @@
 void ResourceDispatcherHost::BeginSaveFile(const GURL& url,
                                            const GURL& referrer,
                                            int process_id,
                                            int route_id,
                                            URLRequestContext* request_context) {
   if (is_shutdown_)
     return;
 
   // Ensure the Chrome plugins are loaded, as they may intercept network
   // requests.  Does nothing if they are already loaded.
-  plugin_service_->LoadChromePlugins(this);
+  PluginService::GetInstance()->LoadChromePlugins(this);
 
   scoped_refptr<ResourceHandler> handler =
       new SaveFileResourceHandler(process_id,
                                   route_id,
                                   url,
                                   save_file_manager_.get());
   request_id_--;
 
   bool known_proto = URLRequest::IsHandledURL(url);
   if (!known_proto) {
@@ skipping 505 matching lines @@
   request->Start();
 
   // Make sure we have the load state monitor running
   if (!update_load_states_timer_.IsRunning()) {
     update_load_states_timer_.Start(
         TimeDelta::FromMilliseconds(kUpdateLoadStatesIntervalMsec),
         this, &ResourceDispatcherHost::UpdateLoadStates);
   }
 }
 
-// This test mirrors the decision that WebKit makes in
-// WebFrameLoaderClient::dispatchDecidePolicyForMIMEType.
-// static.
-bool ResourceDispatcherHost::ShouldDownload(
-    const std::string& mime_type, const std::string& content_disposition) {
-  std::string type = StringToLowerASCII(mime_type);
-  std::string disposition = StringToLowerASCII(content_disposition);
-
-  // First, examine content-disposition.
-  if (!disposition.empty()) {
-    bool should_download = true;
-
-    // Some broken sites just send ...
-    //    Content-Disposition: ; filename="file"
-    // ... screen those out here.
-    if (disposition[0] == ';')
-      should_download = false;
-
-    if (disposition.compare(0, 6, "inline") == 0)
-      should_download = false;
-
-    // Some broken sites just send ...
-    //    Content-Disposition: filename="file"
-    // ... without a disposition token... Screen those out.
-    if (disposition.compare(0, 8, "filename") == 0)
-      should_download = false;
-
-    // Also in use is Content-Disposition: name="file"
-    if (disposition.compare(0, 4, "name") == 0)
-      should_download = false;
-
-    // We have a content-disposition of "attachment" or unknown.
-    // RFC 2183, section 2.8 says that an unknown disposition
-    // value should be treated as "attachment".
-    if (should_download)
-      return true;
-  }
-
-  // MIME type checking.
-  if (net::IsSupportedMimeType(type))
-    return false;
-
-  // Finally, check the plugin service.
-  bool allow_wildcard = false;
-  return !plugin_service_->HavePluginFor(type, allow_wildcard);
-}
-
 bool ResourceDispatcherHost::PauseRequestIfNeeded(ExtraRequestInfo* info) {
   if (info->pause_count > 0)
     info->is_paused = true;
 
   return info->is_paused;
 }
 
 void ResourceDispatcherHost::ResumeRequest(const GlobalRequestID& request_id) {
   PendingRequestList::iterator i = pending_requests_.find(request_id);
   if (i == pending_requests_.end())  // The request may have been destroyed
@@ skipping 421 matching lines @@
     case ViewHostMsg_UploadProgress_ACK::ID:
     case ViewHostMsg_SyncLoad::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }