Move RenderViewHostManager back to tab_contents. Moving it to renderer_host...

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 12 matching lines @@
 #include "chrome/browser/external_protocol_handler.h"
 #include "chrome/browser/in_process_webkit/webkit_thread.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/privacy_blacklist/blacklist.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/async_resource_handler.h"
 #include "chrome/browser/renderer_host/buffered_resource_handler.h"
 #include "chrome/browser/renderer_host/cross_site_resource_handler.h"
 #include "chrome/browser/renderer_host/download_resource_handler.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
+#include "chrome/browser/renderer_host/render_view_host_delegate.h"
 #include "chrome/browser/renderer_host/resource_request_details.h"
 #include "chrome/browser/renderer_host/safe_browsing_resource_handler.h"
 #include "chrome/browser/renderer_host/save_file_resource_handler.h"
 #include "chrome/browser/renderer_host/sync_resource_handler.h"
 #include "chrome/browser/ssl/ssl_client_auth_handler.h"
+#include "chrome/browser/ssl/ssl_manager.h"
 #include "chrome/browser/tab_contents/tab_util.h"
-#include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/render_messages.h"
 #include "net/base/auth.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/url_request/url_request.h"
@@ skipping 51 matching lines @@
 
 // Maximum number of pending data messages sent to the renderer at any
 // given time for a given request.
 const int kMaxPendingDataMessages = 20;
 
 // Maximum byte "cost" of all the outstanding requests for a renderer.
 // See delcaration of |max_outstanding_requests_cost_per_process_| for details.
 // This bound is 25MB, which allows for around 6000 outstanding requests.
 const int kMaxOutstandingRequestsCostPerProcess = 26214400;
 
+// A NotificationTask proxies a resource dispatcher notification from the IO
+// thread to the RenderViewHostDelegate on the UI thread. It should be
+// constructed on the IO thread and run in the UI thread.
+class NotificationTask : public Task {
+ public:
+  // Supply the originating URLRequest, a function on RenderViewHostDelegate
+  // to call, and the details to use as the parameter to the given function.
+  //
+  // This object will take ownership of the details pointer, which must be
+  // allocated on the heap.
+  NotificationTask(
+      URLRequest* request,
+      void (RenderViewHostDelegate::* function)(ResourceRequestDetails*),
+      ResourceRequestDetails* details)
+      : function_(function),
+        details_(details) {
+    if (!ResourceDispatcherHost::RenderViewForRequest(request,
+                                                      &render_process_host_id_,
+                                                      &render_view_host_id_))
+      NOTREACHED();
+  }
+
+  virtual void Run() {
+    RenderViewHost* rvh = RenderViewHost::FromID(render_process_host_id_,
+                                                 render_view_host_id_);
+    if (rvh)
+      (rvh->delegate()->*function_)(details_.get());
+  }
+
+ private:
+  int render_process_host_id_;
+  int render_view_host_id_;
+
+  // The function to call on RenderViewHostDelegate on the UI thread.
+  void (RenderViewHostDelegate::* function_)(ResourceRequestDetails*);
+
+  // The details for the notification.
+  scoped_ptr<ResourceRequestDetails> details_;
+
+  DISALLOW_COPY_AND_ASSIGN(NotificationTask);
+};
+
 // Consults the RendererSecurity policy to determine whether the
 // ResourceDispatcherHost should service this request.  A request might be
 // disallowed if the renderer is not authorized to restrive the request URL or
 // if the renderer is attempting to upload an unauthorized file.
 bool ShouldServiceRequest(ChildProcessInfo::ProcessType process_type,
                           int process_id,
                           const ViewHostMsg_Resource_Request& request_data)  {
   if (process_type == ChildProcessInfo::PLUGIN_PROCESS)
     return true;
 
@@ skipping 1197 matching lines @@
   // unit_tests.
   DCHECK(MessageLoop::current() == io_loop_ && io_loop_);
 
   PendingRequestList::const_iterator i = pending_requests_.find(request_id);
   if (i == pending_requests_.end())
     return NULL;
 
   return i->second;
 }
 
-// A NotificationTask proxies a resource dispatcher notification from the IO
-// thread to the UI thread.  It should be constructed on the IO thread and run
-// in the UI thread.  Takes ownership of |details|.
-class NotificationTask : public Task {
- public:
-  NotificationTask(NotificationType type,
-                   URLRequest* request,
-                   ResourceRequestDetails* details)
-  : type_(type),
-    details_(details) {
-    if (!ResourceDispatcherHost::RenderViewForRequest(request,
-                                                      &process_id_,
-                                                      &tab_contents_id_))
-      NOTREACHED();
-  }
-
-  void Run() {
-    // Find the tab associated with this request.
-    TabContents* tab_contents =
-        tab_util::GetTabContentsByID(process_id_, tab_contents_id_);
-
-    if (tab_contents) {
-      // Issue the notification.
-      NotificationService::current()->Notify(
-          type_,
-          Source<NavigationController>(&tab_contents->controller()),
-          Details<ResourceRequestDetails>(details_.get()));
-    }
-  }
-
- private:
-  // These IDs let us find the correct tab on the UI thread.
-  int process_id_;
-  int tab_contents_id_;
-
-  // The type and details of the notification.
-  NotificationType type_;
-  scoped_ptr<ResourceRequestDetails> details_;
-};
-
 static int GetCertID(URLRequest* request, int process_id) {
   if (request->ssl_info().cert) {
     return CertStore::GetSharedInstance()->StoreCert(request->ssl_info().cert,
                                                      process_id);
   }
   // If there is no SSL info attached to this request, we must either be a non
   // secure request, or the request has been canceled or failed (before the SSL
   // info was populated), or the response is an error (we have seen 403, 404,
   // and 501) made up by the proxy.
   DCHECK(!request->url().SchemeIsSecure() ||
          (request->status().status() == URLRequestStatus::CANCELED) ||
          (request->status().status() == URLRequestStatus::FAILED) ||
          ((request->response_headers()->response_code() >= 400) &&
          (request->response_headers()->response_code() <= 599)));
   return 0;
 }
 
 void ResourceDispatcherHost::NotifyResponseStarted(URLRequest* request,
                                                    int process_id) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_, OnRequestStarted(this, request));
 
   // Notify the observers on the UI thread.
-  ui_loop_->PostTask(FROM_HERE,
-      new NotificationTask(NotificationType::RESOURCE_RESPONSE_STARTED, request,
-                           new ResourceRequestDetails(request,
-                               GetCertID(request, process_id))));
+  ui_loop_->PostTask(FROM_HERE, new NotificationTask(request,
+      &RenderViewHostDelegate::DidStartReceivingResourceResponse,
+      new ResourceRequestDetails(request,
+         GetCertID(request, process_id))));
 }
 
 void ResourceDispatcherHost::NotifyResponseCompleted(
     URLRequest* request,
     int process_id) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnResponseCompleted(this, request));
-
-  // Notify the observers on the UI thread.
-  ui_loop_->PostTask(FROM_HERE,
-      new NotificationTask(NotificationType::RESOURCE_RESPONSE_COMPLETED,
-                           request,
-                           new ResourceRequestDetails(request,
-                               GetCertID(request, process_id))));
 }
 
 void ResourceDispatcherHost::NotifyReceivedRedirect(URLRequest* request,
                                                     int process_id,
                                                     const GURL& new_url) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnReceivedRedirect(this, request, new_url));
 
   int cert_id = GetCertID(request, process_id);
 
   // Notify the observers on the UI thread.
   ui_loop_->PostTask(FROM_HERE,
-      new NotificationTask(NotificationType::RESOURCE_RECEIVED_REDIRECT,
-                           request,
+      new NotificationTask(request,
+                           &RenderViewHostDelegate::DidRedirectResource,
                            new ResourceRedirectDetails(request,
                                                        cert_id,
                                                        new_url)));
 }
 
 namespace {
 
 // This function attempts to return the "more interesting" load state of |a|
 // and |b|.  We don't have temporal information about these load states
 // (meaning we don't know when we transitioned into these states), so we just
@@ skipping 179 matching lines @@
     case ViewHostMsg_UploadProgress_ACK::ID:
     case ViewHostMsg_SyncLoad::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }