Refactor host network

chrome_frame/chrome_frame_automation.cc

 // Copyright (c) 2009 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_frame/chrome_frame_automation.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
@@ skipping 390 matching lines @@
       parent_window_(NULL),
       automation_server_(NULL),
       automation_server_id_(NULL),
       ui_thread_id_(NULL),
       init_state_(UNINITIALIZED),
       use_chrome_network_(false),
       proxy_factory_(g_proxy_factory.get()),
       handle_top_level_requests_(false),
       tab_handle_(-1),
       external_tab_cookie_(NULL),
+      url_fetcher_(NULL),
       navigate_after_initialization_(false) {
 }
 
 ChromeFrameAutomationClient::~ChromeFrameAutomationClient() {
   // Uninitialize must be called prior to the destructor
   DCHECK(automation_server_ == NULL);
 }
 
 bool ChromeFrameAutomationClient::Initialize(
     ChromeFrameDelegate* chrome_frame_delegate,
@@ skipping 65 matching lines @@
   // 1) Make ReleaseAutomationServer blocking call (wait until thread exits)
   // 2) Behave like a COM object i.e. increase module lock count.
   // Otherwise the DLL may get unloaded while we have running threads.
   // Unfortunately in NPAPI case we cannot increase module lock count, hence
   // we stick with blocking/waiting
   if (tab_.get()) {
     tab_->RemoveObserver(this);
     tab_ = NULL;    // scoped_refptr::Release
   }
 
-  // Clean up any outstanding requests
-  CleanupRequests();
+  if (url_fetcher_) {
+    // Clean up any outstanding requests
+    url_fetcher_->StopAllRequests();
+  }
 
   // Wait for the background thread to exit.
   ReleaseAutomationServer();
 
   // We must destroy the window, since if there are pending tasks
   // window procedure may be invoked after DLL is unloaded.
   // Unfortunately pending tasks are leaked.
   if (m_hWnd)
     DestroyWindow();
 
@@ skipping 335 matching lines @@
       chrome_frame_delegate_->OnAutomationServerLaunchFailed(result, version);
     }
   }
 }
 
 // This is invoked in channel's background thread.
 // Cannot call any method of the activex/npapi here since they are STA
 // kind of beings.
 // By default we marshal the IPC message to the main/GUI thread and from there
 // we safely invoke chrome_frame_delegate_->OnMessageReceived(msg).
+
+
+bool ChromeFrameAutomationClient::ProcessUrlRequestMessage(TabProxy* tab,
+    const IPC::Message& msg, bool ui_thread) {
+  // Either directly call appropriate url_fetcher function
+  // or postpone call to the UI thread.
+  bool invoke = ui_thread || thread_safe_url_fetcher_;
+  uint16 msg_type = msg.type();
+  switch (msg_type) {
+    default:
+      return false;
+
+    case AutomationMsg_RequestStart::ID:
+      if (invoke)
+        AutomationMsg_RequestStart::Dispatch(&msg, url_fetcher_,
+            &PluginUrlRequestManager::StartUrlRequest);
+      break;
+
+    case AutomationMsg_RequestRead::ID:
+      if (invoke)
+        AutomationMsg_RequestRead::Dispatch(&msg, url_fetcher_,
+            &PluginUrlRequestManager::ReadUrlRequest);
+      break;
+
+    case AutomationMsg_RequestEnd::ID:
+      if (invoke)
+        AutomationMsg_RequestEnd::Dispatch(&msg, url_fetcher_,
+            &PluginUrlRequestManager::EndUrlRequest);
+      break;
+  }
+
+  if (!invoke) {
+    PostTask(FROM_HERE, NewRunnableMethod(this,
+        &ChromeFrameAutomationClient::ProcessUrlRequestMessage,
+        tab, msg, true));
+  }
+
+  return true;
+}
+
 void ChromeFrameAutomationClient::OnMessageReceived(TabProxy* tab,
                                                     const IPC::Message& msg) {
   DCHECK(tab == tab_.get());
 
+  // Quickly process network related messages.
+  if (url_fetcher_ && ProcessUrlRequestMessage(tab, msg, false))
+    return;
+
   // Early check to avoid needless marshaling
   if (chrome_frame_delegate_ == NULL)
     return;
 
   CallDelegate(FROM_HERE, NewRunnableMethod(chrome_frame_delegate_,
       &ChromeFrameDelegate::OnMessageReceived, msg));
 }
 
 void ChromeFrameAutomationClient::ReportNavigationError(
     AutomationMsg_NavigationResponseValues error_code,
@@ skipping 124 matching lines @@
          window_dc, print_bounds.left, print_bounds.top,
          SRCCOPY);
 
   ::ReleaseDC(tab_window_, window_dc);
 }
 
 void ChromeFrameAutomationClient::PrintTab() {
   tab_->PrintAsync();
 }
 
-// IPC:Message::Sender implementation
-bool ChromeFrameAutomationClient::Send(IPC::Message* msg) {
-  if (automation_server_) {
-    return automation_server_->Send(msg);
-  }
-  return false;
-}
-
-bool ChromeFrameAutomationClient::AddRequest(PluginUrlRequest* request) {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
-
-  if (!request) {
-    NOTREACHED();
-    return false;
-  }
-
-#ifndef NDEBUG
-  RequestMap::const_iterator it = request_map_.find(request->id());
-  scoped_refptr<PluginUrlRequest> other(request_map_.end() == it ?
-                                        NULL : (*it).second);
-  DCHECK(other.get() == NULL);
-#endif
-  request_map_[request->id()] = request;
-  return true;
-}
-
-bool ChromeFrameAutomationClient::ReadRequest(
-    int request_id, int bytes_to_read) {
-  bool result = false;
-  PluginUrlRequest* request = LookupRequest(request_id);
-  if (request)
-    result = request->Read(bytes_to_read);
-
-  return result;
-}
-
-void ChromeFrameAutomationClient::RemoveRequest(PluginUrlRequest* request) {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
-
-  // We check if the request pointer passed in is actually present in the map
-  // before going ahead and deleting it. This avoids the issue where we would
-  // incorrectly delete a different request with the same request id.
-  if (IsValidRequest(request)) {
-    request_map_.erase(request->id());
-  }
-}
-
-void ChromeFrameAutomationClient::RemoveRequest(int request_id, bool abort) {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
-  PluginUrlRequest* request = LookupRequest(request_id);
-  if (request) {
-    if (abort) {
-      // The request object will get removed asynchronously.
-      request->Stop();
-    } else {
-      request_map_.erase(request_id);
-    }
-  }
-}
-
-PluginUrlRequest* ChromeFrameAutomationClient::LookupRequest(
-    int request_id) const {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
-  PluginUrlRequest* request = NULL;
-  RequestMap::const_iterator it = request_map_.find(request_id);
-  if (request_map_.end() != it)
-    request = (*it).second;
-  return request;
-}
-
-bool ChromeFrameAutomationClient::IsValidRequest(
-    PluginUrlRequest* request) const {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
-  bool is_valid = false;
-  // if request is invalid then request->id() won't work
-  // hence perform reverse map lookup for validity of the
-  // request pointer.
-  if (request) {
-    for (RequestMap::const_iterator it = request_map_.begin();
-         it != request_map_.end(); it++) {
-      if (request == (*it).second) {
-        is_valid = true;
-        break;
-      }
-    }
-  }
-
-  return is_valid;
-}
-
-void ChromeFrameAutomationClient::CleanupRequests() {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
-
-  std::vector<scoped_refptr<PluginUrlRequest> > request_list;
-  // We copy the pending requests into a temporary vector as the Stop
-  // function in the request could also try to delete the request from
-  // the request map and the iterator could end up being invalid.
-  RequestMap::iterator index = request_map_.begin();
-  while (index != request_map_.end()) {
-    PluginUrlRequest* request = (*index).second;
-    DCHECK(request != NULL);
-    request_list.push_back(request);
-    index++;
-  }
-  request_map_.clear();
-
-  for (unsigned int index = 0; index < request_list.size(); ++index) {
-    request_list[index]->Stop();
-  }
-}
-
 bool ChromeFrameAutomationClient::Reinitialize(
-    ChromeFrameDelegate* delegate) {
+    ChromeFrameDelegate* delegate,
+    PluginUrlRequestManager* url_fetcher) {
   if (!tab_.get() || !::IsWindow(chrome_window_)) {
     NOTREACHED();
     DLOG(WARNING) << "ChromeFrameAutomationClient instance reused "
                   << "with invalid tab";
     return false;
   }
 
   if (!delegate) {
     NOTREACHED();
     return false;
   }
 
-  CleanupRequests();
+  url_fetcher_->StopAllRequests();
   chrome_frame_delegate_ = delegate;
+  SetUrlFetcher(url_fetcher);
   SetParentWindow(NULL);
   return true;
 }
 
 void ChromeFrameAutomationClient::AttachExternalTab(
     intptr_t external_tab_cookie) {
   DCHECK_EQ(static_cast<TabProxy*>(NULL), tab_.get());
   DCHECK_EQ(-1, tab_handle_);
 
   external_tab_cookie_ = external_tab_cookie;
 }
 
 void ChromeFrameAutomationClient::SetPageFontSize(
     enum AutomationPageFontSize font_size) {
   if (font_size < SMALLEST_FONT ||
       font_size > LARGEST_FONT) {
       NOTREACHED() << "Invalid font size specified : "
                    << font_size;
       return;
   }
 
-  Send(new AutomationMsg_SetPageFontSize(0, tab_handle_, font_size));
+  automation_server_->Send(
+      new AutomationMsg_SetPageFontSize(0, tab_handle_, font_size));
 }
 
+
+//////////////////////////////////////////////////////////////////////////
+// PluginUrlRequestDelegate implementation.
+// Forward network related responses to Chrome.
+
+void ChromeFrameAutomationClient::OnResponseStarted(int request_id,
+    const char* mime_type,  const char* headers, int size,
+    base::Time last_modified, const std::string& peristent_cookies,
+    const std::string& redirect_url, int redirect_status) {
+  const IPC::AutomationURLResponse response = {
+      mime_type,
+      headers ? headers : "",
+      size,
+      last_modified,
+      peristent_cookies,
+      redirect_url,
+      redirect_status
+  };
+
+  automation_server_->Send(new AutomationMsg_RequestStarted(0,
+      tab_->handle(), request_id, response));
+}
+
+void ChromeFrameAutomationClient::OnReadComplete(int request_id,
+                                                 const void* buffer, int len) {
+  std::string data(reinterpret_cast<const char*>(buffer), len);
+  automation_server_->Send(new AutomationMsg_RequestData(0, tab_->handle(),
+      request_id, data));
+}
+
+void ChromeFrameAutomationClient::OnResponseEnd(int request_id,
+    const URLRequestStatus& status) {
+  automation_server_->Send(new AutomationMsg_RequestEnd(0, tab_->handle(),
+      request_id, status));
+}
+