Include base/win/scoped_comptr.h instead of base/scoped_comptr_win.h.

chrome_frame/chrome_active_document.cc

 // Copyright (c) 2011 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 12 matching lines @@
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_local.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_variant.h"
 #include "base/win/win_util.h"
-#include "grit/generated_resources.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/test/automation/browser_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome_frame/bho.h"
 #include "chrome_frame/bind_context_info.h"
 #include "chrome_frame/buggy_bho_handling.h"
 #include "chrome_frame/crash_reporting/crash_metrics.h"
 #include "chrome_frame/utils.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/navigation_types.h"
 #include "content/common/page_zoom.h"
+#include "grit/generated_resources.h"
 
 DEFINE_GUID(CGID_DocHostCmdPriv, 0x000214D4L, 0, 0, 0xC0, 0, 0, 0, 0, 0, 0,
             0x46);
 
 base::ThreadLocalPointer<ChromeActiveDocument> g_active_doc_cache;
 
 bool g_first_launch_by_process_ = true;
 
 const DWORD kIEEncodingIdArray[] = {
 #define DEFINE_ENCODING_ID_ARRAY(encoding_name, id, chrome_name) encoding_name,
@@ skipping 89 matching lines @@
   // the user opens a new IE window with a URL that has us as the DocObject.
   // Here we refuse to be activated in-place and we will force IE to UIActivate
   // us.
   if (OLEIVERB_INPLACEACTIVATE == verb)
     return OLEOBJ_E_INVALIDVERB;
   // Check if we should activate as a docobject or not
   // (client supports IOleDocumentSite)
   if (doc_site_) {
     switch (verb) {
     case OLEIVERB_SHOW: {
-      ScopedComPtr<IDocHostUIHandler> doc_host_handler;
+      base::win::ScopedComPtr<IDocHostUIHandler> doc_host_handler;
       doc_host_handler.QueryFrom(doc_site_);
       if (doc_host_handler.get())
         doc_host_handler->ShowUI(DOCHOSTUITYPE_BROWSE, this, this, NULL, NULL);
     }
     case OLEIVERB_OPEN:
     case OLEIVERB_UIACTIVATE:
       if (!m_bUIActive)
         return doc_site_->ActivateMe(NULL);
       break;
     }
@@ skipping 40 matching lines @@
   BaseActiveX::GiveFocusToChrome(true);
 }
 
 STDMETHODIMP ChromeActiveDocument::Load(BOOL fully_avalable,
                                         IMoniker* moniker_name,
                                         LPBC bind_context,
                                         DWORD mode) {
   if (NULL == moniker_name)
     return E_INVALIDARG;
 
-  ScopedComPtr<IOleClientSite> client_site;
+  base::win::ScopedComPtr<IOleClientSite> client_site;
   if (bind_context) {
-    ScopedComPtr<IUnknown> site;
+    base::win::ScopedComPtr<IUnknown> site;
     bind_context->GetObjectParam(SZ_HTML_CLIENTSITE_OBJECTPARAM,
                                  site.Receive());
     if (site)
       client_site.QueryFrom(site);
   }
 
   if (client_site) {
     SetClientSite(client_site);
     DoQueryService(IID_INewWindowManager, client_site,
                    popup_manager_.Receive());
 
     // See if mshtml parsed the html header for us.  If so, we need to
     // clear the browser service flag that we use to indicate that this
     // browser instance is navigating to a CF document.
-    ScopedComPtr<IBrowserService> browser_service;
+    base::win::ScopedComPtr<IBrowserService> browser_service;
     DoQueryService(SID_SShellBrowser, client_site, browser_service.Receive());
     if (browser_service) {
       bool flagged = CheckForCFNavigation(browser_service, true);
       DVLOG_IF(1, flagged) << "Cleared flagged browser service";
     }
   }
 
   NavigationManager* mgr = NavigationManager::GetThreadInstance();
   DLOG_IF(ERROR, !mgr) << "Couldn't get instance of NavigationManager";
 
   std::wstring url;
 
-  ScopedComPtr<BindContextInfo> info;
+  base::win::ScopedComPtr<BindContextInfo> info;
   BindContextInfo::FromBindContext(bind_context, info.Receive());
   DCHECK(info);
   if (info && !info->GetUrl().empty()) {
     url = info->GetUrl();
     if (mgr) {
       // If the original URL contains an anchor, then the URL queried
       // from the protocol sink wrapper does not contain the anchor. To
       // workaround this we retrieve the anchor from the navigation manager
       // and append it to the url retrieved from the protocol sink wrapper.
       GURL url_for_anchor(mgr->url());
@@ skipping 284 matching lines @@
 HRESULT ChromeActiveDocument::IOleObject_SetClientSite(
     IOleClientSite* client_site) {
   if (client_site == NULL) {
     ChromeActiveDocument* cached_document = g_active_doc_cache.Get();
     if (cached_document) {
       DCHECK(this == cached_document);
       g_active_doc_cache.Set(NULL);
       cached_document->Release();
     }
 
-    ScopedComPtr<IDocHostUIHandler> doc_host_handler;
+    base::win::ScopedComPtr<IDocHostUIHandler> doc_host_handler;
     if (doc_site_)
       doc_host_handler.QueryFrom(doc_site_);
 
     if (doc_host_handler.get())
       doc_host_handler->HideUI();
 
     doc_site_.Release();
   }
 
   if (client_site != m_spClientSite)
     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();
     if (FAILED(hr))
       return hr;
     m_spInPlaceSite->OnInPlaceActivate();
   }
   m_bInPlaceActive = TRUE;
   // get location in the parent window,
   // as well as some information about the parent
-  ScopedComPtr<IOleInPlaceUIWindow> in_place_ui_window;
+  base::win::ScopedComPtr<IOleInPlaceUIWindow> in_place_ui_window;
   frame_info_.cb = sizeof(OLEINPLACEFRAMEINFO);
   HWND parent_window = NULL;
   if (m_spInPlaceSite->GetWindow(&parent_window) == S_OK) {
     in_place_frame_.Release();
     RECT position_rect = {0};
     RECT clip_rect = {0};
     m_spInPlaceSite->GetWindowContext(in_place_frame_.Receive(),
                                       in_place_ui_window.Receive(),
                                       &position_rect,
                                       &clip_rect,
                                       &frame_info_);
     if (!m_bWndLess) {
       if (IsWindow()) {
         ::ShowWindow(m_hWnd, SW_SHOW);
         SetFocus();
       } else {
         m_hWnd = Create(parent_window, position_rect);
         if (!IsWindow()) {
           // This might happen if the automation server couldn't be
           // instantiated.  If so, a NOTREACHED() will have already been hit.
           DLOG(ERROR) << "Failed to create Ax window";
           return AtlHresultFromLastError();
         }
       }
     }
     SetObjectRects(&position_rect, &clip_rect);
   }
 
-  ScopedComPtr<IOleInPlaceActiveObject> in_place_active_object(this);
+  base::win::ScopedComPtr<IOleInPlaceActiveObject> in_place_active_object(this);
 
   // Gone active by now, take care of UIACTIVATE
   if (DoesVerbUIActivate(verb)) {
     if (!m_bUIActive) {
       m_bUIActive = TRUE;
       hr = m_spInPlaceSite->OnUIActivate();
       if (FAILED(hr))
         return hr;
       // set ourselves up in the host
       if (in_place_active_object) {
@@ skipping 79 matching lines @@
       CrashMetricsReporter::CHROME_FRAME_NAVIGATION_COUNT);
 
   UpdateNavigationState(nav_info, 0);
 }
 
 void ChromeActiveDocument::OnCloseTab() {
   // Base class will fire DIChromeFrameEvents::onclose.
   BaseActiveX::OnCloseTab();
 
   // Close the container window.
-  ScopedComPtr<IWebBrowser2> web_browser2;
+  base::win::ScopedComPtr<IWebBrowser2> web_browser2;
   DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive());
   if (web_browser2)
     web_browser2->Quit();
 }
 
 void ChromeActiveDocument::UpdateNavigationState(
     const NavigationInfo& new_navigation_info, int flags) {
   // This could be NULL if the active document instance is being destroyed.
   if (!m_spInPlaceSite) {
     DVLOG(1) << __FUNCTION__ << "m_spInPlaceSite is NULL. Returning";
@@ skipping 26 matching lines @@
     IEExec(&CGID_ShellDocView, INTERNAL_CMDID_SET_SSL_LOCK,
            OLECMDEXECOPT_DODEFAULT, secure_lock_status.AsInput(), NULL);
   }
 
   // A number of poorly written bho's crash in their event sink callbacks if
   // chrome frame is the currently loaded document. This is because they expect
   // chrome frame to implement interfaces like IHTMLDocument, etc. We patch the
   // event sink's of these bho's and don't invoke the event sink if chrome
   // frame is the currently loaded document.
   if (GetConfigBool(true, kEnableBuggyBhoIntercept)) {
-    ScopedComPtr<IWebBrowser2> wb2;
+    base::win::ScopedComPtr<IWebBrowser2> wb2;
     DoQueryService(SID_SWebBrowserApp, m_spClientSite, wb2.Receive());
     if (wb2 && buggy_bho::BuggyBhoTls::GetInstance()) {
       buggy_bho::BuggyBhoTls::GetInstance()->PatchBuggyBHOs(wb2);
     }
   }
 
   // Ideally all navigations should come to Chrome Frame so that we can call
   // BeforeNavigate2 on installed BHOs and give them a chance to cancel the
   // navigation. However, in practice what happens is as below:
   // The very first navigation that happens in CF happens via a Load or a
@@ skipping 13 matching lines @@
   bool is_attach_external_tab_url = cf_url.Parse(std::wstring(url_)) &&
       cf_url.attach_to_external_tab();
 
   bool is_internal_navigation =
       IsNewNavigation(new_navigation_info, flags) || is_attach_external_tab_url;
 
   if (new_navigation_info.url.is_valid())
     url_.Allocate(UTF8ToWide(new_navigation_info.url.spec()).c_str());
 
   if (is_internal_navigation) {
-    ScopedComPtr<IDocObjectService> doc_object_svc;
-    ScopedComPtr<IWebBrowserEventsService> web_browser_events_svc;
+    base::win::ScopedComPtr<IDocObjectService> doc_object_svc;
+    base::win::ScopedComPtr<IWebBrowserEventsService> web_browser_events_svc;
 
     DoQueryService(__uuidof(web_browser_events_svc), m_spClientSite,
                    web_browser_events_svc.Receive());
 
     if (!web_browser_events_svc.get()) {
       DoQueryService(SID_SShellBrowser, m_spClientSite,
                      doc_object_svc.Receive());
     }
 
     // web_browser_events_svc can be NULL on IE6.
@@ skipping 172 matching lines @@
   // Allow popup
   if (hr == S_OK) {
     BaseActiveX::OnAttachExternalTab(params);
     return;
   }
 
   automation_client_->BlockExternalTab(params.cookie);
 }
 
 bool ChromeActiveDocument::PreProcessContextMenu(HMENU menu) {
-  ScopedComPtr<IBrowserService> browser_service;
-  ScopedComPtr<ITravelLog> travel_log;
+  base::win::ScopedComPtr<IBrowserService> browser_service;
+  base::win::ScopedComPtr<ITravelLog> travel_log;
   GetBrowserServiceAndTravelLog(browser_service.Receive(),
                                 travel_log.Receive());
   if (!browser_service || !travel_log)
     return true;
 
   EnableMenuItem(menu, IDC_BACK, MF_BYCOMMAND |
       (SUCCEEDED(travel_log->GetTravelEntry(browser_service, TLOG_BACK,
                                             NULL)) ?
       MF_ENABLED : MF_DISABLED));
   EnableMenuItem(menu, IDC_FORWARD, MF_BYCOMMAND |
       (SUCCEEDED(travel_log->GetTravelEntry(browser_service, TLOG_FORE,
                                             NULL)) ?
       MF_ENABLED : MF_DISABLED));
   // Call base class (adds 'About' item)
   return BaseActiveX::PreProcessContextMenu(menu);
 }
 
 bool ChromeActiveDocument::HandleContextMenuCommand(
     UINT cmd, const MiniContextMenuParams& params) {
-  ScopedComPtr<IWebBrowser2> web_browser2;
+  base::win::ScopedComPtr<IWebBrowser2> web_browser2;
   DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive());
 
   if (cmd == IDC_BACK)
     web_browser2->GoBack();
   else if (cmd == IDC_FORWARD)
     web_browser2->GoForward();
   else if (cmd == IDC_RELOAD)
     web_browser2->Refresh();
   else
     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;
 
-  ScopedComPtr<IOleCommandTarget> frame_cmd_target;
+  base::win::ScopedComPtr<IOleCommandTarget> frame_cmd_target;
 
-  ScopedComPtr<IOleInPlaceSite> in_place_site(m_spInPlaceSite);
+  base::win::ScopedComPtr<IOleInPlaceSite> in_place_site(m_spInPlaceSite);
   if (!in_place_site.get() && m_spClientSite != NULL)
     in_place_site.QueryFrom(m_spClientSite);
 
   if (in_place_site)
     hr = frame_cmd_target.QueryFrom(in_place_site);
 
   if (frame_cmd_target) {
     hr = frame_cmd_target->Exec(cmd_group_guid, command_id, cmd_exec_opt,
                                 in_args, out_args);
   }
@@ skipping 205 matching lines @@
   // to update the menu state to indicate that which encoding was set.
   // TODO(iyengar)
   // Do some investigation into why this Exec call fails.
   IEExec(&CGID_ExplorerBarDoc, command_id, cmd_exec_opt, NULL, NULL);
   return S_OK;
 }
 
 void ChromeActiveDocument::OnGoToHistoryEntryOffset(int offset) {
   DVLOG(1) <<  __FUNCTION__ << " - offset:" << offset;
 
-  ScopedComPtr<IBrowserService> browser_service;
-  ScopedComPtr<ITravelLog> travel_log;
+  base::win::ScopedComPtr<IBrowserService> browser_service;
+  base::win::ScopedComPtr<ITravelLog> travel_log;
   GetBrowserServiceAndTravelLog(browser_service.Receive(),
                                 travel_log.Receive());
 
   if (browser_service && travel_log)
     travel_log->Travel(browser_service, offset);
 }
 
 void ChromeActiveDocument::OnMoveWindow(const gfx::Rect& dimensions) {
-  ScopedComPtr<IWebBrowser2> web_browser2;
+  base::win::ScopedComPtr<IWebBrowser2> web_browser2;
   DoQueryService(SID_SWebBrowserApp, m_spClientSite,
                  web_browser2.Receive());
   if (!web_browser2)
     return;
   DVLOG(1) << "this:" << this << "\ndimensions: width:" << dimensions.width()
            << " height:" << dimensions.height();
   if (!dimensions.IsEmpty()) {
     web_browser2->put_MenuBar(VARIANT_FALSE);
     web_browser2->put_ToolBar(VARIANT_FALSE);
 
     int width = dimensions.width();
     int height = dimensions.height();
     // Compute the size of the browser window given the desired size of the
     // content area. As per MSDN, the WebBrowser object returns an error from
     // this method. As a result the code below is best effort.
     web_browser2->ClientToWindow(&width, &height);
 
     web_browser2->put_Width(width);
     web_browser2->put_Height(height);
     web_browser2->put_Left(dimensions.x());
     web_browser2->put_Top(dimensions.y());
   }
 }
 
 HRESULT ChromeActiveDocument::GetBrowserServiceAndTravelLog(
     IBrowserService** browser_service, ITravelLog** travel_log) {
   DCHECK(browser_service || travel_log);
-  ScopedComPtr<IBrowserService> browser_service_local;
+  base::win::ScopedComPtr<IBrowserService> browser_service_local;
   HRESULT hr = DoQueryService(SID_SShellBrowser, m_spClientSite,
                               browser_service_local.Receive());
   if (!browser_service_local) {
     NOTREACHED() << "DoQueryService for IBrowserService failed: " << hr;
     return hr;
   }
 
   if (travel_log) {
     hr = browser_service_local->GetTravelLog(travel_log);
     DVLOG_IF(1, !travel_log) << "browser_service->GetTravelLog failed: " << hr;
   }
 
   if (browser_service)
     *browser_service = browser_service_local.Detach();
 
   return hr;
 }
 
 LRESULT ChromeActiveDocument::OnForward(WORD notify_code, WORD id,
                                         HWND control_window,
                                         BOOL& bHandled) {
-  ScopedComPtr<IWebBrowser2> web_browser2;
+  base::win::ScopedComPtr<IWebBrowser2> web_browser2;
   DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive());
   DCHECK(web_browser2);
 
   if (web_browser2)
     web_browser2->GoForward();
   return 0;
 }
 
 LRESULT ChromeActiveDocument::OnBack(WORD notify_code, WORD id,
                                      HWND control_window,
                                      BOOL& bHandled) {
-  ScopedComPtr<IWebBrowser2> web_browser2;
+  base::win::ScopedComPtr<IWebBrowser2> web_browser2;
   DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive());
   DCHECK(web_browser2);
 
   if (web_browser2)
     web_browser2->GoBack();
   return 0;
 }
 
 LRESULT ChromeActiveDocument::OnFirePrivacyChange(UINT message, WPARAM wparam,
                                                   LPARAM lparam,
                                                   BOOL& handled) {
   if (!m_spClientSite)
     return 0;
 
-  ScopedComPtr<IWebBrowser2> web_browser2;
+  base::win::ScopedComPtr<IWebBrowser2> web_browser2;
   DoQueryService(SID_SWebBrowserApp, m_spClientSite,
                  web_browser2.Receive());
   if (!web_browser2) {
     NOTREACHED() << "Failed to retrieve IWebBrowser2 interface.";
     return 0;
   }
 
-  ScopedComPtr<IShellBrowser> shell_browser;
+  base::win::ScopedComPtr<IShellBrowser> shell_browser;
   DoQueryService(SID_STopLevelBrowser, web_browser2,
                  shell_browser.Receive());
   DCHECK(shell_browser.get() != NULL);
-  ScopedComPtr<ITridentService2> trident_services;
+  base::win::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;
 }
 
 LRESULT ChromeActiveDocument::OnShowWindow(UINT message, WPARAM wparam,
                                            LPARAM lparam,
@@ skipping 37 matching lines @@
     return true;
 
   if (new_navigation_info.url != navigation_info_->url)
     return true;
 
   if (new_navigation_info.referrer != navigation_info_->referrer)
     return true;
 
   return false;
 }