Remove ResourceDispatcherHost dependency on Chrome's LoginHandler and ExternalProtocolHandler.

content/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2011 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 "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/shared_memory.h"
 #include "base/stl_util-inl.h"
 #include "base/time.h"
 #include "chrome/browser/download/download_file_manager.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/download/download_request_limiter.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/download/save_file_manager.h"
-#include "chrome/browser/external_protocol/external_protocol_handler.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/download_resource_handler.h"
 #include "chrome/browser/renderer_host/save_file_resource_handler.h"
 #include "chrome/browser/ssl/ssl_client_auth_handler.h"
 #include "chrome/browser/ssl/ssl_manager.h"
-#include "chrome/browser/ui/login/login_prompt.h"
-#include "chrome/common/chrome_switches.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/cert_store.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/chrome_blob_storage_context.h"
 #include "content/browser/content_browser_client.h"
 #include "content/browser/cross_site_request_manager.h"
 #include "content/browser/in_process_webkit/webkit_thread.h"
 #include "content/browser/plugin_service.h"
 #include "content/browser/resource_context.h"
 #include "content/browser/renderer_host/async_resource_handler.h"
 #include "content/browser/renderer_host/buffered_resource_handler.h"
 #include "content/browser/renderer_host/cross_site_resource_handler.h"
 #include "content/browser/renderer_host/global_request_id.h"
 #include "content/browser/renderer_host/redirect_to_file_resource_handler.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_notification_task.h"
+#include "content/browser/renderer_host/resource_dispatcher_host_delegate.h"
+#include "content/browser/renderer_host/resource_dispatcher_host_login_delegate.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "content/browser/renderer_host/resource_message_filter.h"
 #include "content/browser/renderer_host/resource_queue.h"
 #include "content/browser/renderer_host/resource_request_details.h"
 #include "content/browser/renderer_host/sync_resource_handler.h"
 #include "content/browser/worker_host/worker_service.h"
+#include "content/common/content_switches.h"
 #include "content/common/notification_service.h"
 #include "content/common/resource_messages.h"
 #include "content/common/url_constants.h"
 #include "content/common/view_messages.h"
 #include "net/base/auth.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
@@ skipping 168 matching lines @@
       download_request_limiter_(new DownloadRequestLimiter()),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           save_file_manager_(new SaveFileManager(this))),
       webkit_thread_(new WebKitThread),
       request_id_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_runner_(this)),
       is_shutdown_(false),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       filter_(NULL),
-      observer_(NULL),
+      delegate_(NULL),
       allow_cross_origin_auth_prompt_(false) {
   resource_queue_.Initialize(resource_queue_delegates);
 }
 
 ResourceDispatcherHost::~ResourceDispatcherHost() {
   AsyncResourceHandler::GlobalCleanup();
   STLDeleteValues(&pending_requests_);
 }
 
 void ResourceDispatcherHost::Initialize() {
@@ skipping 49 matching lines @@
     int route_id,
     const GURL& url,
     ResourceType::Type type,
     const net::URLRequestJobFactory& job_factory,
     ResourceHandler* handler) {
   if (!ResourceType::IsFrame(type) ||
       job_factory.IsHandledURL(url)) {
     return false;
   }
 
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(
-          &ExternalProtocolHandler::LaunchUrl, url, child_id, route_id));
+  if (delegate_)
+    delegate_->HandleExternalProtocol(url, child_id, route_id);
 
   handler->OnResponseCompleted(
       request_id,
       net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_ABORTED),
       std::string());  // No security info necessary.
   return true;
 }
 
 bool ResourceDispatcherHost::OnMessageReceived(const IPC::Message& message,
                                                ResourceMessageFilter* filter,
@@ skipping 60 matching lines @@
 
   if (is_shutdown_ ||
       !ShouldServiceRequest(process_type, child_id, request_data)) {
     AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
     return;
   }
 
   const GURL referrer = MaybeStripReferrer(request_data.referrer);
 
   // Allow the observer to block/handle the request.
-  if (observer_ && !observer_->ShouldBeginRequest(child_id, route_id,
+  if (delegate_ && !delegate_->ShouldBeginRequest(child_id, route_id,
                                                   request_data,
                                                   resource_context,
                                                   referrer)) {
     AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
     return;
   }
 
   // Construct the event handler.
   scoped_refptr<ResourceHandler> handler;
   if (sync_result) {
@@ skipping 78 matching lines @@
     // has a chance to run before we render the new page.
     handler = new CrossSiteResourceHandler(handler,
                                            child_id,
                                            route_id,
                                            this);
   }
 
   // Insert a buffered event handler before the actual one.
   handler = new BufferedResourceHandler(handler, this, request);
 
-  if (observer_) {
+  if (delegate_) {
     bool sub = request_data.resource_type != ResourceType::MAIN_FRAME;
-    ResourceHandler* temp_handler = handler;
-    observer_->RequestBeginning(
-        &temp_handler, request, sub, child_id, route_id);
-    handler = temp_handler;
+    handler = delegate_->RequestBeginning(
+        handler, request, sub, child_id, route_id);
   }
 
   // Make extra info and read footer (contains request ID).
   ResourceDispatcherHostRequestInfo* extra_info =
       new ResourceDispatcherHostRequestInfo(
           handler,
           process_type,
           child_id,
           route_id,
           request_data.origin_pid,
@@ skipping 195 matching lines @@
       new DownloadResourceHandler(this,
                                   child_id,
                                   route_id,
                                   request_id_,
                                   url,
                                   download_file_manager_.get(),
                                   request,
                                   prompt_for_save_location,
                                   save_info));
 
-  if (observer_) {
-    ResourceHandler* temp_handler = handler;
-    observer_->DownloadStarting(&temp_handler, child_id, route_id);
-    handler = temp_handler;
-  }
+  if (delegate_)
+    handler = delegate_->DownloadStarting(handler, child_id, route_id);
 
   const net::URLRequestContext* request_context = context.request_context();
 
   if (!request_context->job_factory()->IsHandledURL(url)) {
     VLOG(1) << "Download request for unsupported protocol: "
             << url.possibly_invalid_spec();
     return;
   }
 
   request->set_method("GET");
@@ skipping 235 matching lines @@
 void ResourceDispatcherHost::RemovePendingRequest(
     const PendingRequestList::iterator& iter) {
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(iter->second);
 
   // Remove the memory credit that we added when pushing the request onto
   // the pending list.
   IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
                                          info->child_id());
 
   // Notify interested parties that the request object is going away.
-  if (info->login_handler())
-    info->login_handler()->OnRequestCancelled();
+  if (info->login_delegate())
+    info->login_delegate()->OnRequestCancelled();
   if (info->ssl_client_auth_handler())
     info->ssl_client_auth_handler()->OnRequestCancelled();
   resource_queue_.RemoveRequest(iter->first);
 
   delete iter->second;
   pending_requests_.erase(iter);
 
   // If we have no more pending requests, then stop the load state monitor
   if (pending_requests_.empty())
     update_load_states_timer_.Stop();
@@ skipping 41 matching lines @@
 }
 
 void ResourceDispatcherHost::OnAuthRequired(
     net::URLRequest* request,
     net::AuthChallengeInfo* auth_info) {
   if (request->load_flags() & net::LOAD_DO_NOT_PROMPT_FOR_LOGIN) {
     request->CancelAuth();
     return;
   }
 
-  if (observer_ && !observer_->AcceptAuthRequest(request, auth_info)) {
+  if (delegate_ && !delegate_->AcceptAuthRequest(request, auth_info)) {
     request->CancelAuth();
     return;
   }
 
   // Prevent third-party content from prompting for login, unless it is
   // a proxy that is trying to authenticate.  This is often the foundation
   // of a scam to extract credentials for another domain from the user.
   if (!auth_info->is_proxy) {
     HttpAuthResourceType resource_type = HttpAuthResourceTypeOf(request);
     UMA_HISTOGRAM_ENUMERATION("Net.HttpAuthResource",
                               resource_type,
                               HTTP_AUTH_RESOURCE_LAST);
 
     if (resource_type == HTTP_AUTH_RESOURCE_BLOCKED_CROSS) {
       request->CancelAuth();
       return;
     }
   }
 
 
   // Create a login dialog on the UI thread to get authentication data,
   // or pull from cache and continue on the IO thread.
   // TODO(mpcomplete): We should block the parent tab while waiting for
   // authentication.
   // That would also solve the problem of the net::URLRequest being cancelled
   // before we receive authentication.
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
-  DCHECK(!info->login_handler()) <<
-      "OnAuthRequired called with login_handler pending";
-  info->set_login_handler(CreateLoginPrompt(auth_info, request));
+  DCHECK(!info->login_delegate()) <<
+      "OnAuthRequired called with login_delegate pending";
+  if (delegate_) {
+    info->set_login_delegate(delegate_->CreateLoginDelegate(
+        auth_info, request));
+  }
+  if (!info->login_delegate())
+    request->CancelAuth();
 }
 
 void ResourceDispatcherHost::OnCertificateRequested(
     net::URLRequest* request,
     net::SSLCertRequestInfo* cert_request_info) {
   DCHECK(request);
-  if (observer_ && !observer_->AcceptSSLClientCertificateRequest(
+  if (delegate_ && !delegate_->AcceptSSLClientCertificateRequest(
           request, cert_request_info)) {
     request->Cancel();
     return;
   }
 
   if (cert_request_info->client_certs.empty()) {
     // No need to query the user if there are no certs to choose from.
     request->ContinueWithCertificate(NULL);
     return;
   }
@@ skipping 132 matching lines @@
 }
 
 bool ResourceDispatcherHost::CancelRequestInternal(net::URLRequest* request,
                                                    bool from_renderer) {
   VLOG(1) << "CancelRequest: " << request->url().spec();
 
   // WebKit will send us a cancel for downloads since it no longer handles them.
   // In this case, ignore the cancel since we handle downloads in the browser.
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   if (!from_renderer || !info->is_download()) {
-    if (info->login_handler()) {
-      info->login_handler()->OnRequestCancelled();
-      info->set_login_handler(NULL);
+    if (info->login_delegate()) {
+      info->login_delegate()->OnRequestCancelled();
+      info->set_login_delegate(NULL);
     }
     if (info->ssl_client_auth_handler()) {
       info->ssl_client_auth_handler()->OnRequestCancelled();
       info->set_ssl_client_auth_handler(NULL);
     }
     request->Cancel();
     // Our callers assume |request| is valid after we return.
     DCHECK(IsValidRequest(request));
     return true;
   }
@@ skipping 112 matching lines @@
   bool defer_start = false;
   if (!info->resource_handler()->OnWillStart(
           info->request_id(), request->url(),
           &defer_start)) {
     CancelRequestInternal(request, false);
     return;
   }
 
   // TODO(cbentzel): Should we isolate this to resource handlers instead of
   // adding an interface to the observer?
-  if (!defer_start && observer_ && filter_) {
-    defer_start = observer_->ShouldDeferStart(request,
+  if (!defer_start && delegate_ && filter_) {
+    defer_start = delegate_->ShouldDeferStart(request,
                                               filter_->resource_context());
   }
 
   if (!defer_start)
     InsertIntoResourceQueue(request, *info);
 }
 
 void ResourceDispatcherHost::InsertIntoResourceQueue(
     net::URLRequest* request,
     const ResourceDispatcherHostRequestInfo& request_info) {
@@ skipping 631 matching lines @@
 
 bool ResourceDispatcherHost::allow_cross_origin_auth_prompt() {
   return allow_cross_origin_auth_prompt_;
 }
 
 void ResourceDispatcherHost::set_allow_cross_origin_auth_prompt(bool value) {
   allow_cross_origin_auth_prompt_ = value;
 }