Refactor host network

chrome_frame/chrome_frame_automation.h

 // 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.
 
 #ifndef CHROME_FRAME_CHROME_FRAME_AUTOMATION_H_
 #define CHROME_FRAME_CHROME_FRAME_AUTOMATION_H_
 
 #include <atlbase.h>
 #include <atlwin.h>
 #include <string>
@@ skipping 130 matching lines @@
   // Interval for sending UMA data
   int uma_send_interval_;
 };
 
 // Handles all automation requests initiated from the chrome frame objects.
 // These include the chrome tab/chrome frame activex/chrome frame npapi
 // plugin objects.
 class ChromeFrameAutomationClient
     : public CWindowImpl<ChromeFrameAutomationClient>,
       public TaskMarshallerThroughWindowsMessages<ChromeFrameAutomationClient>,
-      public PluginRequestHandler,
+      public base::RefCountedThreadSafe<ChromeFrameAutomationClient>,
+      public PluginUrlRequestDelegate,
       public TabProxy::TabProxyDelegate,
       public ProxyFactory::LaunchDelegate {
  public:
   ChromeFrameAutomationClient();
   ~ChromeFrameAutomationClient();
 
   // Called from UI thread.
   virtual bool Initialize(ChromeFrameDelegate* chrome_frame_delegate,
                           int automation_server_launch_timeout,
                           bool perform_version_check,
@@ skipping 58 matching lines @@
   // Returns the version number of plugin dll.
   std::wstring GetVersion() const;
 
   // BitBlts the contents of the chrome window to the print dc.
   void Print(HDC print_dc, const RECT& print_bounds);
 
   // Called in full tab mode and indicates a request to chrome to print
   // the whole tab.
   void PrintTab();
 
-  // PluginRequestHandler
-  bool AddRequest(PluginUrlRequest* request);
-  void RemoveRequest(PluginUrlRequest* request);
-  virtual bool Send(IPC::Message* msg);
-
-  // URL request related
-  bool ReadRequest(int request_id, int bytes_to_read);
-  void RemoveRequest(int request_id, bool abort);
-  PluginUrlRequest* LookupRequest(int request_id) const;
-  bool IsValidRequest(PluginUrlRequest* request) const;
-  void CleanupRequests();
-
   void set_use_chrome_network(bool use_chrome_network) {
     use_chrome_network_ = use_chrome_network;
   }
   bool use_chrome_network() const {
     return use_chrome_network_;
   }
 
 #ifdef UNIT_TEST
   void set_proxy_factory(ProxyFactory* factory) {
     proxy_factory_ = factory;
   }
 #endif
 
   void set_handle_top_level_requests(bool handle_top_level_requests) {
     handle_top_level_requests_ = handle_top_level_requests;
   }
 
   // Called if the same instance of the ChromeFrameAutomationClient object
   // is reused.
-  bool Reinitialize(ChromeFrameDelegate* chrome_frame_delegate);
+  bool Reinitialize(ChromeFrameDelegate* chrome_frame_delegate,
+                    PluginUrlRequestManager* url_fetcher);
 
   // Attaches an existing external tab to this automation client instance.
   void AttachExternalTab(intptr_t external_tab_cookie);
 
   void SetPageFontSize(enum AutomationPageFontSize);
 
  protected:
   // ChromeFrameAutomationProxy::LaunchDelegate implementation.
   virtual void LaunchComplete(ChromeFrameAutomationProxy* proxy,
                             AutomationLaunchResult result);
   // TabProxyDelegate implementation
   virtual void OnMessageReceived(TabProxy* tab, const IPC::Message& msg);
 
   void CreateExternalTab();
   void CreateExternalTabComplete(HWND chrome_window, HWND tab_window,
                                  int tab_handle);
   // Called in UI thread. Here we fire event to the client notifying for
   // the result of Initialize() method call.
   void InitializeComplete(AutomationLaunchResult result);
 
  private:
-  typedef std::map<int, scoped_refptr<PluginUrlRequest> > RequestMap;
-
   // Usage: From bkgnd thread invoke:
   // CallDelegate(FROM_HERE, NewRunnableMethod(chrome_frame_delegate_,
   //                                           ChromeFrameDelegate::Something,
   //                                           param1,
   //                                           param2));
   void CallDelegate(const tracked_objects::Location& from_here,
                     Task* delegate_task);
   // The workhorse method called in main/GUI thread which is going to
   // execute ChromeFrameDelegate method encapsulated in delegate_task.
   void CallDelegateImpl(Task* delegate_task);
@@ skipping 21 matching lines @@
   GURL url_;
   GURL referrer_;
 
   // Handle to the underlying chrome window. This is a child of the external
   // tab window.
   HWND tab_window_;
 
   // Keeps track of the version of Chrome we're talking to.
   std::string automation_server_version_;
 
-  // Map of outstanding requests
-  RequestMap request_map_;
-
   typedef enum InitializationState {
     UNINITIALIZED = 0,
     INITIALIZING,
     INITIALIZED,
     UNINITIALIZING,
   };
 
   InitializationState init_state_;
   bool use_chrome_network_;
   bool handle_top_level_requests_;
   ProxyFactory* proxy_factory_;
   int tab_handle_;
   // Only used if we attach to an existing tab.
   intptr_t external_tab_cookie_;
 
   // Set to true if we received a navigation request prior to the automation
   // server being initialized.
   bool navigate_after_initialization_;
 
   ChromeFrameLaunchParams chrome_launch_params_;
+
+  // When host network stack is used, this object is in charge of
+  // handling network requests.
+  PluginUrlRequestManager* url_fetcher_;
+  bool thread_safe_url_fetcher_;
+
+  bool ProcessUrlRequestMessage(TabProxy* tab, const IPC::Message& msg,
+                                bool ui_thread);
+
+  // PluginUrlRequestDelegate implementation. Simply adds tab's handle
+  // as parameter and forwards to Chrome via IPC.
+  virtual void 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);
+  virtual void OnReadComplete(int request_id, const void* buffer, int len);
+  virtual void OnResponseEnd(int request_id, const URLRequestStatus& status);
+
+ public:
+  void SetUrlFetcher(PluginUrlRequestManager* url_fetcher) {
+    DCHECK(url_fetcher != NULL);
+    url_fetcher_ = url_fetcher;
+    thread_safe_url_fetcher_ = url_fetcher->IsThreadSafe();
+    url_fetcher_->set_delegate(this);
+  }
 };
 
 #endif  // CHROME_FRAME_CHROME_FRAME_AUTOMATION_H_