Switch renderer in Moniker patch...

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 67 matching lines @@
                << cached_document;
     DCHECK(automation_client_.get() != NULL);
     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();
+    HRESULT hr = BaseActiveX::FinalConstruct();
     if (FAILED(hr))
       return hr;
   }
 
   bool chrome_network = GetConfigBool(false, kUseChromeNetworking);
   bool top_level_requests = GetConfigBool(true, kHandleTopLevelRequests);
   automation_client_->set_use_chrome_network(chrome_network);
   automation_client_->set_handle_top_level_requests(top_level_requests);
 
   find_dialog_.Init(automation_client_.get());
@@ skipping 13 matching lines @@
   DCHECK(accelerator_table_ != NULL);
   return S_OK;
 }
 
 ChromeActiveDocument::~ChromeActiveDocument() {
   DLOG(INFO) << __FUNCTION__;
   if (find_dialog_.IsWindow()) {
     find_dialog_.DestroyWindow();
   }
   // ChromeFramePlugin
-  Base::Uninitialize();
+  BaseActiveX::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 53 matching lines @@
 
   return S_FALSE;
 }
 // Override IPersistStorageImpl::IsDirty
 STDMETHODIMP ChromeActiveDocument::IsDirty() {
   DLOG(INFO) << __FUNCTION__;
   return S_FALSE;
 }
 
 void ChromeActiveDocument::OnAutomationServerReady() {
-  Base::OnAutomationServerReady();
-  Base::GiveFocusToChrome();
+  BaseActiveX::OnAutomationServerReady();
+  BaseActiveX::GiveFocusToChrome();
 }
 
 STDMETHODIMP ChromeActiveDocument::Load(BOOL fully_avalable,
                                         IMoniker* moniker_name,
                                         LPBC bind_context,
                                         DWORD mode) {
   if (NULL == moniker_name) {
     return E_INVALIDARG;
   }
 
@@ skipping 25 matching lines @@
   NavigationManager* mgr = NavigationManager::GetThreadInstance();
   DCHECK(mgr);
 
   // If the original URL contains an anchor, then the URL queried
   // from the moniker does not contain the anchor. To workaround
   // this we retrieve the URL from our BHO.
   std::wstring url(GetActualUrlFromMoniker(
       moniker_name, bind_context,
       mgr ? mgr->original_url_with_fragment() : std::wstring()));
 
-  scoped_refptr<RequestData> data;
   if (mgr) {
+    mgr->set_url(L"");
     mgr->set_original_url_with_fragment(L"");
-    data = mgr->GetActiveRequestData(url.c_str());
   }
 
-  DLOG_IF(INFO, data) << "Got active request data";
-  DLOG_IF(WARNING, data.get() == NULL) << "NO active request data";
-
   // The is_new_navigation variable indicates if this a navigation initiated
   // by typing in a URL for e.g. in the IE address bar, or from Chrome by
   // a window.open call from javascript, in which case the current IE tab
   // will attach to an existing ExternalTabContainer instance.
   bool is_new_navigation = true;
   bool is_chrome_protocol = false;
 
   if (!ParseUrl(url, &is_new_navigation, &is_chrome_protocol, &url)) {
     DLOG(WARNING) << __FUNCTION__ << " Failed to parse url:" << url;
     return E_INVALIDARG;
@@ skipping 198 matching lines @@
 
     if (doc_host_handler.get()) {
       doc_host_handler->HideUI();
     }
 
     doc_site_.Release();
     in_place_frame_.Release();
   }
 
   if (client_site != m_spClientSite) {
-    return Base::IOleObject_SetClientSite(client_site);
+    return BaseActiveX::IOleObject_SetClientSite(client_site);
   }
 
   return S_OK;
 }
 
 HRESULT ChromeActiveDocument::ActiveXDocActivate(LONG verb) {
   HRESULT hr = S_OK;
   m_bNegotiatedWnd = TRUE;
   if (!m_bInPlaceActive) {
     hr = m_spInPlaceSite->CanInPlaceActivate();
@@ skipping 90 matching lines @@
   if (in_place_frame_ != NULL) {
     handled_accel = (S_OK == in_place_frame_->TranslateAcceleratorW(
         const_cast<MSG*>(&accel_message), 0));
   }
 
   if (!handled_accel) {
     if (IsFindAccelerator(accel_message)) {
       // Handle the showing of the find dialog explicitly.
       OnFindInPage();
     } else {
-      Base::OnAcceleratorPressed(tab_handle, accel_message);
+      BaseActiveX::OnAcceleratorPressed(tab_handle, accel_message);
     }
   } else {
     DLOG(INFO) << "IE handled accel key " << accel_message.wParam;
   }
 }
 
 void ChromeActiveDocument::OnTabbedOut(int tab_handle, bool reverse) {
   DLOG(INFO) << __FUNCTION__;
   if (in_place_frame_) {
     MSG msg = { NULL, WM_KEYDOWN, VK_TAB };
@@ skipping 66 matching lines @@
        navigation_info_.navigation_index)) ||
        StartsWith(static_cast<BSTR>(url_), kChromeAttachExternalTabPrefix,
                   false);
 
   if (new_navigation_info.url.is_valid()) {
     url_.Allocate(UTF8ToWide(new_navigation_info.url.spec()).c_str());
     NavigationManager* mgr = NavigationManager::GetThreadInstance();
     DCHECK(mgr);
     if (mgr) {
       mgr->set_url(url_);
-      mgr->ReleaseRequestData();
     }
   }
 
   if (is_internal_navigation) {
     ScopedComPtr<IDocObjectService> doc_object_svc;
     ScopedComPtr<IWebBrowserEventsService> web_browser_events_svc;
 
     DoQueryService(__uuidof(web_browser_events_svc), m_spClientSite,
                    web_browser_events_svc.Receive());
 
@@ skipping 103 matching lines @@
   // current tab, then we can reuse the ChromeFrameAutomationClient instance
   // maintained by the current ChromeActiveDocument instance. We cache this
   // instance so that it can be used by the new ChromeActiveDocument instance
   // which may be instantiated for handling the new URL.
   if (open_disposition == CURRENT_TAB) {
     // Grab a reference to ensure that the document remains valid.
     AddRef();
     g_active_doc_cache.Set(this);
   }
 
-  Base::OnOpenURL(tab_handle, url_to_open, referrer, open_disposition);
+  BaseActiveX::OnOpenURL(tab_handle, url_to_open, referrer, open_disposition);
 }
 
 void ChromeActiveDocument::OnAttachExternalTab(int tab_handle,
     const IPC::AttachExternalTabParams& params) {
   DWORD flags = 0;
   if (params.user_gesture)
     flags = NWMF_USERREQUESTED;
   else if (popup_allowed_)
     flags = NWMF_USERALLOWED;
 
   HRESULT hr = S_OK;
   if (popup_manager_) {
     LPCWSTR popup_wnd_url = UTF8ToWide(params.url.spec()).c_str();
     hr = popup_manager_->EvaluateNewWindow(popup_wnd_url, NULL, url_,
         NULL, FALSE, flags, 0);
   }
   // Allow popup
   if (hr == S_OK) {
-    Base::OnAttachExternalTab(tab_handle, params);
+    BaseActiveX::OnAttachExternalTab(tab_handle, params);
     return;
   }
 
   automation_client_->BlockExternalTab(params.cookie);
 }
 
 bool ChromeActiveDocument::PreProcessContextMenu(HMENU menu) {
   ScopedComPtr<IBrowserService> browser_service;
   ScopedComPtr<ITravelLog> travel_log;
   GetBrowserServiceAndTravelLog(browser_service.Receive(),
                                 travel_log.Receive());
   if (!browser_service || !travel_log)
     return true;
 
   if (SUCCEEDED(travel_log->GetTravelEntry(browser_service, TLOG_BACK, NULL))) {
     EnableMenuItem(menu, IDS_CONTENT_CONTEXT_BACK, MF_BYCOMMAND | MF_ENABLED);
   } else {
     EnableMenuItem(menu, IDS_CONTENT_CONTEXT_BACK, MF_BYCOMMAND | MFS_DISABLED);
   }
 
   if (SUCCEEDED(travel_log->GetTravelEntry(browser_service, TLOG_FORE, NULL))) {
     EnableMenuItem(menu, IDS_CONTENT_CONTEXT_FORWARD,
                    MF_BYCOMMAND | MF_ENABLED);
   } else {
     EnableMenuItem(menu, IDS_CONTENT_CONTEXT_FORWARD,
                    MF_BYCOMMAND | MFS_DISABLED);
   }
 
   // Call base class (adds 'About' item)
-  return Base::PreProcessContextMenu(menu);
+  return BaseActiveX::PreProcessContextMenu(menu);
 }
 
 bool ChromeActiveDocument::HandleContextMenuCommand(UINT cmd,
     const IPC::ContextMenuParams& params) {
   ScopedComPtr<IWebBrowser2> web_browser2;
   DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive());
 
   switch (cmd) {
     case IDS_CONTENT_CONTEXT_BACK:
       web_browser2->GoBack();
       break;
 
     case IDS_CONTENT_CONTEXT_FORWARD:
       web_browser2->GoForward();
       break;
 
     case IDS_CONTENT_CONTEXT_RELOAD:
       web_browser2->Refresh();
       break;
 
     default:
-      return Base::HandleContextMenuCommand(cmd, params);
+      return BaseActiveX::HandleContextMenuCommand(cmd, params);
   }
 
   return true;
 }
 
 HRESULT ChromeActiveDocument::IEExec(const GUID* cmd_group_guid,
                                      DWORD command_id, DWORD cmd_exec_opt,
                                      VARIANT* in_args, VARIANT* out_args) {
   HRESULT hr = E_FAIL;
 
@@ skipping 350 matching lines @@
   ScopedComPtr<ITridentService2> trident_services;
   trident_services.QueryFrom(shell_browser);
   if (trident_services) {
     trident_services->FirePrivacyImpactedStateChange(wparam);
   } else {
     NOTREACHED() << "Failed to retrieve IWebBrowser2 interface.";
   }
   return 0;
 }