Refactor host network

chrome_frame/chrome_frame_npapi.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_NPAPI_H_
 #define CHROME_FRAME_CHROME_FRAME_NPAPI_H_
 
 #include <atlbase.h>
 #include <atlwin.h>
 #include <string>
@@ skipping 47 matching lines @@
   ~ChromeFrameNPAPI();
 
   bool Initialize(NPMIMEType mime_type, NPP instance, uint16 mode,
                   int16 argc, char* argn[], char* argv[]);
   void Uninitialize();
 
   bool SetWindow(NPWindow* window_info);
   void UrlNotify(const char* url, NPReason reason, void* notify_data);
   bool NewStream(NPMIMEType type, NPStream* stream, NPBool seekable,
                  uint16* stream_type);
+  int32 WriteReady(NPStream* stream);
+  int32 Write(NPStream* stream, int32 offset, int32 len, void* buffer);
+  NPError DestroyStream(NPStream* stream, NPReason reason);
 
   void Print(NPPrint* print_info);
 
   // NPObject functions, which ensure that the plugin object is scriptable.
   static bool HasMethod(NPObject* obj, NPIdentifier name);
   static bool Invoke(NPObject* header, NPIdentifier name,
                      const NPVariant* args, uint32_t arg_count,
                      NPVariant* result);
   static NPObject* AllocateObject(NPP instance, NPClass* class_name);
   static void DeallocateObject(NPObject* header);
@@ skipping 14 matching lines @@
                           const NPVariant *variant);
 
   // Returns the ChromeFrameNPAPI object pointer from the NPP instance structure
   // passed in by the browser.
   static ChromeFrameNPAPI* ChromeFrameInstanceFromPluginInstance(NPP instance);
 
   // Returns the ChromeFrameNPAPI object pointer from the NPObject structure
   // which represents our plugin class.
   static ChromeFrameNPAPI* ChromeFrameInstanceFromNPObject(void* object);
 
-  // Return a UrlRequest instance associated with the given instance and
-  // stream combination.
-  static NPAPIUrlRequest* ValidateRequest(NPP instance, void* notify_data);
-
 BEGIN_MSG_MAP(ChromeFrameNPAPI)
   MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
   CHAIN_MSG_MAP(Base)
 END_MSG_MAP()
 
   LRESULT OnSetFocus(UINT message, WPARAM wparam, LPARAM lparam,
                      BOOL& handled);  // NO_LINT
 
   // Implementation of NpEventDelegate
   virtual void OnEvent(const char* event_name);
@@ skipping 14 matching lines @@
   // Handler for accelerator messages passed on from the hosted chrome
   // instance.
   virtual void OnAcceleratorPressed(int tab_handle, const MSG& accel_message);
   virtual void OnTabbedOut(int tab_handle, bool reverse);
   virtual void OnOpenURL(int tab_handle, const GURL& url, int open_disposition);
   virtual void OnLoad(int tab_handle, const GURL& url);
   virtual void OnMessageFromChromeFrame(int tab_handle,
                                         const std::string& message,
                                         const std::string& origin,
                                         const std::string& target);
-  virtual void OnRequestStart(int tab_handle, int request_id,
-                              const IPC::AutomationURLRequest& request);
-  virtual void OnRequestRead(int tab_handle, int request_id,
-                             int bytes_to_read);
-  virtual void OnRequestEnd(int tab_handle, int request_id,
-                            const URLRequestStatus& status);
   virtual void OnSetCookieAsync(int tab_handle, const GURL& url,
                                 const std::string& cookie);
 
   // ChromeFrameDelegate overrides
   virtual void OnLoadFailed(int error_code, const std::string& url);
   virtual void OnAutomationServerReady();
   virtual void OnAutomationServerLaunchFailed(
       AutomationLaunchResult reason, const std::string& server_version);
   virtual void OnExtensionInstalled(const FilePath& path,
       void* user_data, AutomationMsg_ExtensionResponseValues response);
@@ skipping 120 matching lines @@
   virtual void SetReadyState(READYSTATE new_state) {
     ready_state_ = new_state;
     NPVariant var;
     INT32_TO_NPVARIANT(ready_state_, var);
     FireEvent("readystatechanged", var);
   }
 
   // Host function to compile-time asserts over members of this class.
   static void CompileAsserts();
 
-  // Get request from the stream notify data
-  NPAPIUrlRequest* RequestFromNotifyData(void* notify_data) const;
-
   static LRESULT CALLBACK DropKillFocusHook(int code, WPARAM wparam,
                                             LPARAM lparam);  // NO_LINT
 
   // The plugins opaque instance handle
   NPP instance_;
 
   // The plugin instantiation mode (NP_FULL or NP_EMBED)
   int16 mode_;
   // The plugins mime type.
   std::string mime_type_;
@@ skipping 36 matching lines @@
   // http://www.w3.org/TR/DOM-Level-3-Events/events.html#Event-types
 
   READYSTATE ready_state_;
 
 
   // Popups are enabled
   bool enabled_popups_;
 
   // The value of src property keeping the current URL.
   std::string src_;
+  // Used to fetch network resources when host network stack is in use.
+  NPAPIUrlRequestManager url_fetcher_;
 };
 
 #endif  // CHROME_FRAME_CHROME_FRAME_NPAPI_H_