Refactor host network

chrome_frame/chrome_active_document.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.
 
 // Implementation of ChromeActiveDocument
 #include "chrome_frame/chrome_active_document.h"
 
 #include <hlink.h>
 #include <htiface.h>
 #include <initguid.h>
@@ skipping 36 matching lines @@
             0x46);
 
 
 base::ThreadLocalPointer<ChromeActiveDocument> g_active_doc_cache;
 
 bool g_first_launch_by_process_ = true;
 
 ChromeActiveDocument::ChromeActiveDocument()
     : first_navigation_(true),
       is_automation_client_reused_(false) {
+  url_fetcher_.set_frame_busting(false);
   memset(&navigation_info_, 0, sizeof(navigation_info_));
 }
 
 HRESULT ChromeActiveDocument::FinalConstruct() {
   // If we have a cached ChromeActiveDocument instance in TLS, then grab
   // ownership of the cached document's automation client. This is an
   // optimization to get Chrome active documents to load faster.
   ChromeActiveDocument* cached_document = g_active_doc_cache.Get();
   if (cached_document) {
     DCHECK(automation_client_.get() == NULL);
     automation_client_ = cached_document->automation_client_.release();
     DLOG(INFO) << "Reusing automation client instance from "
                << cached_document;
     DCHECK(automation_client_.get() != NULL);
-    automation_client_->Reinitialize(this);
+    automation_client_->Reinitialize(this, &url_fetcher_);
     is_automation_client_reused_ = true;
   } else {
     // The FinalConstruct implementation in the ChromeFrameActivexBase class
     // i.e. Base creates an instance of the ChromeFrameAutomationClient class
     // and initializes it, which would spawn a new Chrome process, etc.
     // We don't want to be doing this if we have a cached document, whose
     // automation client instance can be reused.
     HRESULT hr = Base::FinalConstruct();
     if (FAILED(hr))
       return hr;
@@ skipping 13 matching lines @@
   enabled_commands_map_[OLECMDID_PASTE] = true;
   enabled_commands_map_[OLECMDID_SELECTALL] = true;
   return S_OK;
 }
 
 ChromeActiveDocument::~ChromeActiveDocument() {
   DLOG(INFO) << __FUNCTION__;
   if (find_dialog_.IsWindow()) {
     find_dialog_.DestroyWindow();
   }
+  // ChromeFramePlugin
+  Base::Uninitialize();
 }
 
 // Override DoVerb
 STDMETHODIMP ChromeActiveDocument::DoVerb(LONG verb,
                                           LPMSG msg,
                                           IOleClientSite* active_site,
                                           LONG index,
                                           HWND parent_window,
                                           LPCRECT pos) {
   // IE will try and in-place activate us in some cases. This happens when
@@ skipping 52 matching lines @@
   }
 
   return S_FALSE;
 }
 // Override IPersistStorageImpl::IsDirty
 STDMETHODIMP ChromeActiveDocument::IsDirty() {
   DLOG(INFO) << __FUNCTION__;
   return S_FALSE;
 }
 
-bool ChromeActiveDocument::is_frame_busting_enabled() {
-  return false;
-}
-
 void ChromeActiveDocument::OnAutomationServerReady() {
   Base::OnAutomationServerReady();
   Base::GiveFocusToChrome();
 }
 
 STDMETHODIMP ChromeActiveDocument::Load(BOOL fully_avalable,
                                         IMoniker* moniker_name,
                                         LPBC bind_context,
                                         DWORD mode) {
   if (NULL == moniker_name) {
@@ skipping 33 matching lines @@
     DLOG(WARNING) << __FUNCTION__ << " Failed to parse url:" << url;
     return E_INVALIDARG;
   }
 
   if (!LaunchUrl(url, is_new_navigation)) {
     NOTREACHED() << __FUNCTION__ << " Failed to launch url:" << url;
     return E_INVALIDARG;
   }
 
   if (!is_chrome_protocol) {
-    CComObject<UrlmonUrlRequest>* new_request = NULL;
-    CComObject<UrlmonUrlRequest>::CreateInstance(&new_request);
-    new_request->AddRef();
-
-    if (SUCCEEDED(new_request->ConnectToExistingMoniker(moniker_name,
-                                                        bind_context,
-                                                        url))) {
-      base_url_request_.swap(&new_request);
-      DCHECK(new_request == NULL);
-    } else {
-      new_request->Release();
-    }
+    url_fetcher_.UseMonikerForUrl(moniker_name, bind_context, url);
   }
 
   UMA_HISTOGRAM_CUSTOM_COUNTS("ChromeFrame.FullTabLaunchType",
                               is_chrome_protocol, 0, 1, 2);
   return S_OK;
 }
 
 STDMETHODIMP ChromeActiveDocument::Save(IMoniker* moniker_name,
                                         LPBC bind_context,
                                         BOOL remember) {
@@ skipping 610 matching lines @@
         DLOG(ERROR) << "Invalid URL: " << url;
         Error(L"Invalid URL");
         url_.Reset();
         return false;
       }
 
       DLOG(INFO) << "Url is " << url_;
     }
   }
 
-  if (!is_automation_client_reused_ &&
-      !InitializeAutomation(GetHostProcessName(false), L"", IsIEInPrivate())) {
-    return false;
-  }
+  if (is_automation_client_reused_)
+    return true;
 
-  return true;
+  automation_client_->SetUrlFetcher(&url_fetcher_);
+
+  if (InitializeAutomation(GetHostProcessName(false), L"", IsIEInPrivate()))
+    return true;
+
+  return false;
 }
 
 HRESULT ChromeActiveDocument::SetPageFontSize(const GUID* cmd_group_guid,
                                               DWORD command_id,
                                               DWORD cmd_exec_opt,
                                               VARIANT* in_args,
                                               VARIANT* out_args) {
   if (!automation_client_.get()) {
     NOTREACHED() << "Invalid automtion client";
     return E_FAIL;
@@ skipping 64 matching lines @@
     hr = browser_service_local->GetTravelLog(travel_log);
     DLOG_IF(INFO, !travel_log) << "browser_service->GetTravelLog failed: "
         << hr;
   }
 
   if (browser_service)
     *browser_service = browser_service_local.Detach();
 
   return hr;
 }