Refactor host network

chrome_frame/chrome_frame_npapi.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_npapi.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 251 matching lines @@
       onprivatemessage_handler_ = JavascriptToNPObject(onprivatemessage_arg);
 
     if (chrome_extra_arguments_arg)
       extra_arguments = UTF8ToWide(chrome_extra_arguments_arg);
 
     if (chrome_profile_name_arg)
       profile_name = UTF8ToWide(chrome_profile_name_arg);
 
     if (chrome_network_arg_set)
       automation_client_->set_use_chrome_network(chrome_network_arg);
+  }
 
-  }
+  // Setup Url fetcher.
+  url_fetcher_.set_NPPInstance(instance_);
+  url_fetcher_.set_frame_busting(!is_privileged_);
+  automation_client_->SetUrlFetcher(&url_fetcher_);
 
   // TODO(joshia): Initialize navigation here and send proxy config as
   // part of LaunchSettings
   /*
   if (!src_.empty())
     automation_client_->InitiateNavigation(src_, is_privileged_);
 
   std::string proxy_settings;
   bool has_prefs = pref_service_->Initialize(instance_,
                                              automation_client_.get());
@@ skipping 143 matching lines @@
 }
 
 void ChromeFrameNPAPI::UrlNotify(const char* url, NPReason reason,
                                  void* notify_data) {
   if (enabled_popups_) {
     // We have opened the URL so tell the browser to restore popup settings
     enabled_popups_ = false;
     npapi::PopPopupsEnabledState(instance_);
   }
 
-  // It is now safe to release the additional reference on the request
-  NPAPIUrlRequest* request = RequestFromNotifyData(notify_data);
-  if (request) {
-    request->Stop();
-    request->Release();
-  }
+  url_fetcher_.UrlNotify(url, reason, notify_data);
 }
 
 void ChromeFrameNPAPI::OnAcceleratorPressed(int tab_handle,
                                             const MSG& accel_message) {
   DLOG(INFO) << __FUNCTION__ << " msg:"
       << StringPrintf("0x%04X", accel_message.message) << " key:"
       << accel_message.wParam;
 
   // The host browser does call TranslateMessage on messages like WM_KEYDOWN
   // WM_KEYUP, etc, which will result in messages like WM_CHAR, WM_SYSCHAR, etc
@@ skipping 52 matching lines @@
     default:
       break;
   }
 
   // Tell the browser to temporarily allow popups
   enabled_popups_ = true;
   npapi::PushPopupsEnabledState(instance_, TRUE);
   npapi::GetURLNotify(instance_, url.spec().c_str(), target.c_str(), NULL);
 }
 
-void ChromeFrameNPAPI::OnRequestStart(int tab_handle, int request_id,
-    const IPC::AutomationURLRequest& request) {
-  scoped_refptr<NPAPIUrlRequest> new_request(new NPAPIUrlRequest(instance_));
-  DCHECK(new_request);
-  if (new_request->Initialize(automation_client_.get(), tab_handle,
-                              request_id, request.url, request.method,
-                              request.referrer, request.extra_request_headers,
-                              request.upload_data.get(), !is_privileged_)) {
-    if (new_request->Start()) {
-      // Keep additional reference on request for NPSTREAM
-      // This will be released in NPP_UrlNotify
-      new_request->AddRef();
-    }
-  }
-}
-
-void ChromeFrameNPAPI::OnRequestRead(int tab_handle, int request_id,
-                                     int bytes_to_read) {
-  automation_client_->ReadRequest(request_id, bytes_to_read);
-}
-
-void ChromeFrameNPAPI::OnRequestEnd(int tab_handle, int request_id,
-                                    const URLRequestStatus& status) {
-  automation_client_->RemoveRequest(request_id, true);
-}
-
 void ChromeFrameNPAPI::OnSetCookieAsync(int tab_handle, const GURL& url,
                                         const std::string& cookie) {
   // Use the newer NPAPI way if available
   if (npapi::VersionMinor() >= NPVERS_HAS_URL_AND_AUTH_INFO) {
     npapi::SetValueForURL(instance_, NPNURLVCookie, url.spec().c_str(),
                           cookie.c_str(), cookie.length());
   } else if (url == GURL(document_url_)) {
     std::string script = "javascript:document.cookie=";
     script.append(cookie);
     script.append(1, ';');
@@ skipping 879 matching lines @@
     if (err == NPERR_NO_ERROR && private_mode) {
       incognito_mode = true;
     }
   } else {
     DLOG(WARNING) << "Not checking for private mode in Opera";
   }
 
   return incognito_mode;
 }
 
-NPAPIUrlRequest* ChromeFrameNPAPI::ValidateRequest(
-    NPP instance, void* notify_data) {
-  ChromeFrameNPAPI* plugin_instance =
-      ChromeFrameNPAPI::ChromeFrameInstanceFromPluginInstance(instance);
-  if (plugin_instance) {
-    return plugin_instance->RequestFromNotifyData(notify_data);
-  }
-
-  return NULL;
-}
-
-NPAPIUrlRequest* ChromeFrameNPAPI::RequestFromNotifyData(
-    void* notify_data) const {
-  NPAPIUrlRequest* request = reinterpret_cast<NPAPIUrlRequest*>(notify_data);
-  DCHECK(request ? automation_client_->IsValidRequest(request) : 1);
-  return request;
-}
-
 bool ChromeFrameNPAPI::HandleContextMenuCommand(UINT cmd,
     const IPC::ContextMenuParams& params) {
   if (cmd == IDC_ABOUT_CHROME_FRAME) {
     // TODO: implement "About Chrome Frame"
   }
   return false;
 }
+
+bool ChromeFrameNPAPI::NewStream(NPMIMEType type, NPStream* stream,
+                                 NPBool seekable, uint16* stream_type) {
+  return url_fetcher_.NewStream(type, stream, seekable, stream_type);
+}
+
+int32 ChromeFrameNPAPI::WriteReady(NPStream* stream) {
+  return url_fetcher_.WriteReady(stream);
+}
+
+int32 ChromeFrameNPAPI::Write(NPStream* stream, int32 offset, int32 len,
+                              void* buffer) {
+  return url_fetcher_.Write(stream, offset, len, buffer);
+}
+
+NPError ChromeFrameNPAPI::DestroyStream(NPStream* stream, NPReason reason) {
+  return url_fetcher_.DestroyStream(stream, reason);
+}