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

chrome_frame/test/ie_event_sink.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.
 
 #include "chrome_frame/test/ie_event_sink.h"
 
 #include <shlguid.h>
 #include <shobjidl.h>
 
 #include "base/string_util.h"
@@ skipping 156 matching lines @@
   chrome_frame_test::KillProcesses(chrome_frame_test::kIEImageName, 0,
                                    !abnormal_shutdown_);
   chrome_frame_test::KillProcesses(chrome_frame_test::kIEBrokerImageName, 0,
                                    !abnormal_shutdown_);
 }
 
 bool IEEventSink::IsCFRendering() {
   DCHECK(web_browser2_);
 
   if (web_browser2_) {
-    ScopedComPtr<IDispatch> doc;
+    base::win::ScopedComPtr<IDispatch> doc;
     web_browser2_->get_Document(doc.Receive());
     if (doc) {
       // Detect if CF is rendering based on whether the document is a
       // ChromeActiveDocument. Detecting based on hwnd is problematic as
       // the CF Active Document window may not have been created yet.
-      ScopedComPtr<IChromeFrame> chrome_frame;
+      base::win::ScopedComPtr<IChromeFrame> chrome_frame;
       chrome_frame.QueryFrom(doc);
       return chrome_frame.get();
     }
   }
   return false;
 }
 
 void IEEventSink::PostMessageToCF(const std::wstring& message,
                                   const std::wstring& target) {
   EXPECT_TRUE(chrome_frame_ != NULL);
@@ skipping 40 matching lines @@
   if (web_browser2_) {
     ScopedBstr address_bar_url;
     EXPECT_EQ(S_OK, web_browser2_->get_LocationURL(address_bar_url.Receive()));
     EXPECT_EQ(expected_url, std::wstring(address_bar_url));
   }
 }
 
 void IEEventSink::Exec(const GUID* cmd_group_guid, DWORD command_id,
                                DWORD cmd_exec_opt, VARIANT* in_args,
                                VARIANT* out_args) {
-  ScopedComPtr<IOleCommandTarget> shell_browser_cmd_target;
+  base::win::ScopedComPtr<IOleCommandTarget> shell_browser_cmd_target;
   DoQueryService(SID_STopLevelBrowser, web_browser2_,
                  shell_browser_cmd_target.Receive());
   ASSERT_TRUE(NULL != shell_browser_cmd_target);
   EXPECT_HRESULT_SUCCEEDED(shell_browser_cmd_target->Exec(cmd_group_guid,
       command_id, cmd_exec_opt, in_args, out_args));
 }
 
 HWND IEEventSink::GetBrowserWindow() {
   HWND browser_window = NULL;
   web_browser2_->get_HWND(reinterpret_cast<SHANDLE_PTR*>(&browser_window));
   EXPECT_TRUE(::IsWindow(browser_window));
   return browser_window;
 }
 
 HWND IEEventSink::GetRendererWindow() {
   HWND renderer_window = NULL;
   if (IsCFRendering()) {
     DCHECK(chrome_frame_);
-    ScopedComPtr<IOleWindow> ole_window;
+    base::win::ScopedComPtr<IOleWindow> ole_window;
     ole_window.QueryFrom(chrome_frame_);
     EXPECT_TRUE(ole_window.get());
 
     if (ole_window) {
       HWND activex_window = NULL;
       ole_window->GetWindow(&activex_window);
       EXPECT_TRUE(IsWindow(activex_window));
 
       wchar_t class_name[MAX_PATH] = {0};
       HWND child_window = NULL;
       // chrome tab window is the first (and the only) child of activex
       for (HWND first_child = activex_window; ::IsWindow(first_child);
            first_child = ::GetWindow(first_child, GW_CHILD)) {
         child_window = first_child;
         GetClassName(child_window, class_name, arraysize(class_name));
         if (!_wcsicmp(class_name, L"Chrome_RenderWidgetHostHWND")) {
           renderer_window = child_window;
           break;
         }
       }
     }
   } else {
     DCHECK(web_browser2_);
-    ScopedComPtr<IDispatch> doc;
+    base::win::ScopedComPtr<IDispatch> doc;
     HRESULT hr = web_browser2_->get_Document(doc.Receive());
     EXPECT_HRESULT_SUCCEEDED(hr);
     EXPECT_TRUE(doc);
     if (doc) {
-      ScopedComPtr<IOleWindow> ole_window;
+      base::win::ScopedComPtr<IOleWindow> ole_window;
       ole_window.QueryFrom(doc);
       EXPECT_TRUE(ole_window);
       if (ole_window) {
         ole_window->GetWindow(&renderer_window);
       }
     }
   }
 
   EXPECT_TRUE(::IsWindow(renderer_window));
   return renderer_window;
 }
 
 HWND IEEventSink::GetRendererWindowSafe() {
   HWND renderer_window = NULL;
   if (IsCFRendering()) {
     DCHECK(chrome_frame_);
-    ScopedComPtr<IOleWindow> ole_window;
+    base::win::ScopedComPtr<IOleWindow> ole_window;
     ole_window.QueryFrom(chrome_frame_);
 
     if (ole_window) {
       HWND activex_window = NULL;
       ole_window->GetWindow(&activex_window);
 
       // chrome tab window is the first (and the only) child of activex
       for (HWND first_child = activex_window; ::IsWindow(first_child);
            first_child = ::GetWindow(first_child, GW_CHILD)) {
         renderer_window = first_child;
       }
       wchar_t class_name[MAX_PATH] = {0};
       GetClassName(renderer_window, class_name, arraysize(class_name));
       if (_wcsicmp(class_name, L"Chrome_RenderWidgetHostHWND") != 0)
         renderer_window = NULL;
     }
   } else {
     DCHECK(web_browser2_);
-    ScopedComPtr<IDispatch> doc;
+    base::win::ScopedComPtr<IDispatch> doc;
     web_browser2_->get_Document(doc.Receive());
     if (doc) {
-      ScopedComPtr<IOleWindow> ole_window;
+      base::win::ScopedComPtr<IOleWindow> ole_window;
       ole_window.QueryFrom(doc);
       if (ole_window) {
         ole_window->GetWindow(&renderer_window);
       }
     }
   }
   if (!::IsWindow(renderer_window))
     renderer_window = NULL;
   return renderer_window;
 }
@@ skipping 33 matching lines @@
 void IEEventSink::Refresh() {
   base::win::ScopedVariant refresh_level(REFRESH_COMPLETELY);
   web_browser2_->Refresh2(refresh_level.AsInput());
 }
 
 // private methods
 void IEEventSink::ConnectToChromeFrame() {
   DCHECK(web_browser2_);
   if (chrome_frame_.get())
     return;
-  ScopedComPtr<IShellBrowser> shell_browser;
+  base::win::ScopedComPtr<IShellBrowser> shell_browser;
   DoQueryService(SID_STopLevelBrowser, web_browser2_,
                  shell_browser.Receive());
 
   if (shell_browser) {
-    ScopedComPtr<IShellView> shell_view;
+    base::win::ScopedComPtr<IShellView> shell_view;
     shell_browser->QueryActiveShellView(shell_view.Receive());
     if (shell_view) {
       shell_view->GetItemObject(SVGIO_BACKGROUND, __uuidof(IChromeFrame),
            reinterpret_cast<void**>(chrome_frame_.Receive()));
     }
 
     if (chrome_frame_) {
       base::win::ScopedVariant onmessage(onmessage_.ToDispatch());
       base::win::ScopedVariant onloaderror(onloaderror_.ToDispatch());
       base::win::ScopedVariant onload(onload_.ToDispatch());
       EXPECT_HRESULT_SUCCEEDED(chrome_frame_->put_onmessage(onmessage));
       EXPECT_HRESULT_SUCCEEDED(chrome_frame_->put_onloaderror(onloaderror));
       EXPECT_HRESULT_SUCCEEDED(chrome_frame_->put_onload(onload));
     }
   }
 }
 
 void IEEventSink::DisconnectFromChromeFrame() {
   if (chrome_frame_) {
     // Use a local ref counted copy of the IChromeFrame interface as the
     // outgoing calls could cause the interface to be deleted due to a message
     // pump running in the context of the outgoing call.
-    ScopedComPtr<IChromeFrame> chrome_frame(chrome_frame_);
+    base::win::ScopedComPtr<IChromeFrame> chrome_frame(chrome_frame_);
     chrome_frame_.Release();
     base::win::ScopedVariant dummy(static_cast<IDispatch*>(NULL));
     chrome_frame->put_onmessage(dummy);
     chrome_frame->put_onload(dummy);
     chrome_frame->put_onloaderror(dummy);
   }
 }
 
 void IEEventSink::FindIEProcessId() {
   HWND hwnd = NULL;
@@ skipping 19 matching lines @@
     return;
 
   if (listener_)
     listener_->OnNewWindow2(dispatch, s);
 
   // Note that |dispatch| is an [in/out] argument. IE is asking listeners if
   // they want to use a IWebBrowser2 of their choice for the new window.
   // Since we need to listen on events on the new browser, we create one
   // if needed.
   if (!*dispatch) {
-    ScopedComPtr<IDispatch> new_browser;
+    base::win::ScopedComPtr<IDispatch> new_browser;
     HRESULT hr = new_browser.CreateInstance(CLSID_InternetExplorer, NULL,
                                             CLSCTX_LOCAL_SERVER);
     DCHECK(SUCCEEDED(hr) && new_browser);
     *dispatch = new_browser.Detach();
   }
 
   if (*dispatch && listener_)
     listener_->OnNewBrowserWindow(*dispatch, ScopedBstr());
 }
 
@@ skipping 57 matching lines @@
     return;
 
   if (listener_)
     listener_->OnNewWindow3(dispatch, cancel, flags, url_context, url);
 
   // Note that |dispatch| is an [in/out] argument. IE is asking listeners if
   // they want to use a IWebBrowser2 of their choice for the new window.
   // Since we need to listen on events on the new browser, we create one
   // if needed.
   if (!*dispatch) {
-    ScopedComPtr<IDispatch> new_browser;
+    base::win::ScopedComPtr<IDispatch> new_browser;
     HRESULT hr = new_browser.CreateInstance(CLSID_InternetExplorer, NULL,
                                             CLSCTX_LOCAL_SERVER);
     DCHECK(SUCCEEDED(hr) && new_browser);
     *dispatch = new_browser.Detach();
   }
 
   if (*dispatch && listener_)
     listener_->OnNewBrowserWindow(*dispatch, url);
 }
 
@@ skipping 60 matching lines @@
           source.Receive(), NULL, NULL));
     }
   }
 
   if (listener_)
     listener_->OnMessage(V_BSTR(&data), V_BSTR(&origin), V_BSTR(&source));
   return S_OK;
 }
 
 }  // namespace chrome_frame_test