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

chrome_frame/chrome_frame_activex.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/chrome_frame_activex.h"
 
 #include <wininet.h>
 
 #include <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_variant.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/automation/tab_proxy.h"
+#include "chrome_frame/utils.h"
 #include "googleurl/src/gurl.h"
-#include "chrome_frame/utils.h"
 
 namespace {
 
 // Class used to maintain a mapping from top-level windows to ChromeFrameActivex
 // instances.
 class TopLevelWindowMapping {
  public:
   typedef std::vector<HWND> WindowList;
 
   static TopLevelWindowMapping* GetInstance() {
@@ skipping 149 matching lines @@
   return 0;
 }
 
 LRESULT ChromeFrameActivex::OnHostMoved(UINT message, WPARAM wparam,
                                         LPARAM lparam, BOOL& handled) {
   Base::OnHostMoved();
   return 0;
 }
 
 HRESULT ChromeFrameActivex::GetContainingDocument(IHTMLDocument2** doc) {
-  ScopedComPtr<IOleContainer> container;
+  base::win::ScopedComPtr<IOleContainer> container;
   HRESULT hr = m_spClientSite->GetContainer(container.Receive());
   if (container)
     hr = container.QueryInterface(doc);
   return hr;
 }
 
 HRESULT ChromeFrameActivex::GetDocumentWindow(IHTMLWindow2** window) {
-  ScopedComPtr<IHTMLDocument2> document;
+  base::win::ScopedComPtr<IHTMLDocument2> document;
   HRESULT hr = GetContainingDocument(document.Receive());
   if (document)
     hr = document->get_parentWindow(window);
   return hr;
 }
 
 void ChromeFrameActivex::OnLoad(const GURL& gurl) {
-  ScopedComPtr<IDispatch> event;
+  base::win::ScopedComPtr<IDispatch> event;
   std::string url = gurl.spec();
   if (SUCCEEDED(CreateDomEvent("event", url, "", event.Receive())))
     Fire_onload(event);
 
   FireEvent(onload_, url);
   Base::OnLoad(gurl);
 }
 
 void ChromeFrameActivex::OnLoadFailed(int error_code, const std::string& url) {
-  ScopedComPtr<IDispatch> event;
+  base::win::ScopedComPtr<IDispatch> event;
   if (SUCCEEDED(CreateDomEvent("event", url, "", event.Receive())))
     Fire_onloaderror(event);
 
   FireEvent(onloaderror_, url);
   Base::OnLoadFailed(error_code, url);
 }
 
 void ChromeFrameActivex::OnMessageFromChromeFrame(const std::string& message,
                                                   const std::string& origin,
                                                   const std::string& target) {
   DVLOG(1) << __FUNCTION__;
 
   if (target.compare("*") != 0) {
     bool drop = true;
 
     if (is_privileged()) {
       // Forward messages if the control is in privileged mode.
-      ScopedComPtr<IDispatch> message_event;
+      base::win::ScopedComPtr<IDispatch> message_event;
       if (SUCCEEDED(CreateDomEvent("message", message, origin,
                                    message_event.Receive()))) {
         base::win::ScopedBstr target_bstr(UTF8ToWide(target).c_str());
         Fire_onprivatemessage(message_event, target_bstr);
 
         FireEvent(onprivatemessage_, message_event, target_bstr);
       }
     } else {
       if (HaveSameOrigin(target, document_url_)) {
         drop = false;
       } else {
         DLOG(WARNING) << "Dropping posted message since target doesn't match "
             "the current document's origin. target=" << target;
       }
     }
 
     if (drop)
       return;
   }
 
-  ScopedComPtr<IDispatch> message_event;
+  base::win::ScopedComPtr<IDispatch> message_event;
   if (SUCCEEDED(CreateDomEvent("message", message, origin,
                                message_event.Receive()))) {
     Fire_onmessage(message_event);
 
     FireEvent(onmessage_, message_event);
 
     base::win::ScopedVariant event_var;
     event_var.Set(static_cast<IDispatch*>(message_event));
     InvokeScriptFunction(onmessage_handler_, event_var.AsInput());
   }
 }
 
 bool ChromeFrameActivex::ShouldShowVersionMismatchDialog(
     bool is_privileged,
     IOleClientSite* client_site) {
   if (!is_privileged) {
     return true;
   }
 
   if (client_site) {
-    ScopedComPtr<IChromeFramePrivileged> service;
+    base::win::ScopedComPtr<IChromeFramePrivileged> service;
     HRESULT hr = DoQueryService(SID_ChromeFramePrivileged,
                                 client_site,
                                 service.Receive());
     if (SUCCEEDED(hr) && service) {
       return (S_FALSE != service->ShouldShowVersionMismatchDialog());
     }
   }
 
   NOTREACHED();
   return true;
@@ skipping 41 matching lines @@
     (L"onmessage"),
     (L"onreadystatechanged"),
   };
 
   base::win::ScopedComPtr<IHTMLObjectElement> obj_element;
   GetObjectElement(obj_element.Receive());
 
   base::win::ScopedBstr object_id;
   GetObjectScriptId(obj_element, object_id.Receive());
 
-  ScopedComPtr<IHTMLElement2> element;
+  base::win::ScopedComPtr<IHTMLElement2> element;
   element.QueryFrom(obj_element);
   HRESULT hr = S_OK;
 
   for (int i = 0; SUCCEEDED(hr) && i < arraysize(event_props); ++i) {
     base::win::ScopedBstr prop(event_props[i]);
     base::win::ScopedVariant value;
     if (SUCCEEDED(bag->Read(prop, value.Receive(), error_log))) {
       if (value.type() != VT_BSTR ||
           FAILED(hr = CreateScriptBlockForEvent(element, object_id,
                                                 V_BSTR(&value), prop))) {
@@ skipping 64 matching lines @@
       &onreadystatechanged_,
       &onextensionready_,
     };
 
     for (int i = 0; i < arraysize(handlers); ++i)
       handlers[i]->clear();
 
     // Drop privileged mode on uninitialization.
     set_is_privileged(false);
   } else {
-    ScopedComPtr<IHTMLDocument2> document;
+    base::win::ScopedComPtr<IHTMLDocument2> document;
     GetContainingDocument(document.Receive());
     if (document) {
       base::win::ScopedBstr url;
       if (SUCCEEDED(document->get_URL(url.Receive())))
         WideToUTF8(url, url.Length(), &document_url_);
     }
 
     // Probe to see whether the host implements the privileged service.
-    ScopedComPtr<IChromeFramePrivileged> service;
+    base::win::ScopedComPtr<IChromeFramePrivileged> service;
     HRESULT service_hr = DoQueryService(SID_ChromeFramePrivileged,
                                         m_spClientSite,
                                         service.Receive());
     if (SUCCEEDED(service_hr) && service) {
       // Does the host want privileged mode?
       boolean wants_privileged = false;
       service_hr = service->GetWantsPrivileged(&wants_privileged);
 
       if (SUCCEEDED(service_hr) && wants_privileged)
         set_is_privileged(true);
@@ skipping 41 matching lines @@
   return hr;
 }
 
 HRESULT ChromeFrameActivex::GetObjectScriptId(IHTMLObjectElement* object_elem,
                                               BSTR* id) {
   DCHECK(object_elem != NULL);
   DCHECK(id != NULL);
 
   HRESULT hr = E_FAIL;
   if (object_elem) {
-    ScopedComPtr<IHTMLElement> elem;
+    base::win::ScopedComPtr<IHTMLElement> elem;
     hr = elem.QueryFrom(object_elem);
     if (elem) {
       hr = elem->get_id(id);
     }
   }
 
   return hr;
 }
 
 HRESULT ChromeFrameActivex::GetObjectElement(IHTMLObjectElement** element) {
   DCHECK(m_spClientSite);
   if (!m_spClientSite)
     return E_UNEXPECTED;
 
-  ScopedComPtr<IOleControlSite> site;
+  base::win::ScopedComPtr<IOleControlSite> site;
   HRESULT hr = site.QueryFrom(m_spClientSite);
   if (site) {
-    ScopedComPtr<IDispatch> disp;
+    base::win::ScopedComPtr<IDispatch> disp;
     hr = site->GetExtendedControl(disp.Receive());
     if (disp) {
       hr = disp.QueryInterface(element);
     } else {
       DCHECK(FAILED(hr));
     }
   }
 
   return hr;
 }
 
 HRESULT ChromeFrameActivex::CreateScriptBlockForEvent(
     IHTMLElement2* insert_after, BSTR instance_id, BSTR script,
     BSTR event_name) {
   DCHECK(insert_after);
   DCHECK_GT(::SysStringLen(event_name), 0UL);  // should always have this
 
   // This might be 0 if not specified in the HTML document.
   if (!::SysStringLen(instance_id)) {
     // TODO(tommi): Should we give ourselves an ID if this happens?
     NOTREACHED() << "Need to handle this";
     return E_INVALIDARG;
   }
 
-  ScopedComPtr<IHTMLDocument2> document;
+  base::win::ScopedComPtr<IHTMLDocument2> document;
   HRESULT hr = GetContainingDocument(document.Receive());
   if (SUCCEEDED(hr)) {
-    ScopedComPtr<IHTMLElement> element, new_element;
+    base::win::ScopedComPtr<IHTMLElement> element, new_element;
     document->createElement(base::win::ScopedBstr(L"script"),
                             element.Receive());
     if (element) {
-      ScopedComPtr<IHTMLScriptElement> script_element;
+      base::win::ScopedComPtr<IHTMLScriptElement> script_element;
       if (SUCCEEDED(hr = script_element.QueryFrom(element))) {
         script_element->put_htmlFor(instance_id);
         script_element->put_event(event_name);
         script_element->put_text(script);
 
         hr = insert_after->insertAdjacentElement(
             base::win::ScopedBstr(L"afterEnd"),
             element,
             new_element.Receive());
       }
     }
   }
 
   return hr;
 }
 
 void ChromeFrameActivex::FireEvent(const EventHandlers& handlers,
                                    const std::string& arg) {
   if (handlers.size()) {
-    ScopedComPtr<IDispatch> event;
+    base::win::ScopedComPtr<IDispatch> event;
     if (SUCCEEDED(CreateDomEvent("event", arg, "", event.Receive()))) {
       FireEvent(handlers, event);
     }
   }
 }
 
 void ChromeFrameActivex::FireEvent(const EventHandlers& handlers,
                                    IDispatch* event) {
   DCHECK(event != NULL);
   VARIANT arg = { VT_DISPATCH };
@@ skipping 28 matching lines @@
     // 0x80020101 == SCRIPT_E_REPORTED.
     // When the script we're invoking has an error, we get this error back.
     DLOG_IF(ERROR, FAILED(hr) && hr != 0x80020101)
         << base::StringPrintf(L"Failed to invoke script: 0x%08X", hr);
   }
 }
 
 HRESULT ChromeFrameActivex::InstallTopLevelHook(IOleClientSite* client_site) {
   // Get the parent window of the site, and install our hook on the topmost
   // window of the parent.
-  ScopedComPtr<IOleWindow> ole_window;
+  base::win::ScopedComPtr<IOleWindow> ole_window;
   HRESULT hr = ole_window.QueryFrom(client_site);
   if (FAILED(hr))
     return hr;
 
   HWND parent_wnd;
   hr = ole_window->GetWindow(&parent_wnd);
   if (FAILED(hr))
     return hr;
 
   HWND top_window = ::GetAncestor(parent_wnd, GA_ROOT);
   chrome_wndproc_hook_ = InstallLocalWindowHook(top_window);
   if (chrome_wndproc_hook_)
     TopLevelWindowMapping::GetInstance()->AddMapping(top_window, m_hWnd);
 
   return chrome_wndproc_hook_ ? S_OK : E_FAIL;
 }
 
 HRESULT ChromeFrameActivex::registerBhoIfNeeded() {
   if (!m_spUnkSite) {
     NOTREACHED() << "Invalid client site";
     return E_FAIL;
   }
 
   if (NavigationManager::GetThreadInstance() != NULL) {
     DVLOG(1) << "BHO already loaded";
     return S_OK;
   }
 
-  ScopedComPtr<IWebBrowser2> web_browser2;
+  base::win::ScopedComPtr<IWebBrowser2> web_browser2;
   HRESULT hr = DoQueryService(SID_SWebBrowserApp, m_spUnkSite,
                               web_browser2.Receive());
   if (FAILED(hr) || web_browser2.get() == NULL) {
     DLOG(WARNING) << "Failed to get IWebBrowser2 from client site. Error:"
                   << base::StringPrintf(" 0x%08X", hr);
     return hr;
   }
 
   wchar_t bho_class_id_as_string[MAX_PATH] = {0};
   StringFromGUID2(CLSID_ChromeFrameBHO, bho_class_id_as_string,
                   arraysize(bho_class_id_as_string));
 
-  ScopedComPtr<IObjectWithSite> bho;
+  base::win::ScopedComPtr<IObjectWithSite> bho;
   hr = bho.CreateInstance(CLSID_ChromeFrameBHO, NULL, CLSCTX_INPROC_SERVER);
   if (FAILED(hr)) {
     NOTREACHED() << "Failed to register ChromeFrame BHO. Error:"
                  << base::StringPrintf(" 0x%08X", hr);
     return hr;
   }
 
   hr = UrlMkSetSessionOption(URLMON_OPTION_USERAGENT_REFRESH, NULL, 0, 0);
   if (FAILED(hr)) {
     DLOG(ERROR) << "Failed to refresh user agent string from registry. "
                 << "UrlMkSetSessionOption returned "
                 << base::StringPrintf("0x%08x", hr);
     return hr;
   }
 
   hr = bho->SetSite(web_browser2);
   if (FAILED(hr)) {
     NOTREACHED() << "ChromeFrame BHO SetSite failed. Error:"
                  << base::StringPrintf(" 0x%08X", hr);
     return hr;
   }
 
   web_browser2->PutProperty(base::win::ScopedBstr(bho_class_id_as_string),
                             base::win::ScopedVariant(bho));
   return S_OK;
 }