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

chrome_frame/utils.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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/utils.h"
 
 #include <atlsafe.h>
 #include <atlsecurity.h>
 #include <htiframe.h>
 #include <mshtml.h>
 #include <shlobj.h>
@@ skipping 23 matching lines @@
 #include "chrome_frame/simple_resource_loader.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon.h"
 #include "grit/chromium_strings.h"
 #include "net/base/escape.h"
 #include "net/http/http_util.h"
 
 #include "chrome_tab.h"  // NOLINT
 
 using base::win::RegKey;
-using base::win::ScopedComPtr;
 
 // Note that these values are all lower case and are compared to
 // lower-case-transformed values.
 const wchar_t kMetaTag[] = L"meta";
 const wchar_t kHttpEquivAttribName[] = L"http-equiv";
 const wchar_t kContentAttribName[] = L"content";
 const wchar_t kXUACompatValue[] = L"x-ua-compatible";
 const wchar_t kBodyTag[] = L"body";
 const wchar_t kChromeContentPrefix[] = L"chrome=";
 const char kGCFProtocol[] = "gcf";
@@ skipping 404 matching lines @@
   }
 
   return ie_version;
 }
 
 FilePath GetIETemporaryFilesFolder() {
   LPITEMIDLIST tif_pidl = NULL;
   HRESULT hr = SHGetFolderLocation(NULL, CSIDL_INTERNET_CACHE, NULL,
                                    SHGFP_TYPE_CURRENT, &tif_pidl);
   if (SUCCEEDED(hr) && tif_pidl) {
-    ScopedComPtr<IShellFolder> parent_folder;
+    base::win::ScopedComPtr<IShellFolder> parent_folder;
     LPITEMIDLIST relative_pidl = NULL;
     hr = SHBindToParent(tif_pidl, IID_IShellFolder,
                         reinterpret_cast<void**>(parent_folder.Receive()),
                         const_cast<LPCITEMIDLIST*>(&relative_pidl));
     if (SUCCEEDED(hr) && relative_pidl) {
       STRRET path = {0};
       hr = parent_folder->GetDisplayNameOf(relative_pidl,
                                            SHGDN_NORMAL | SHGDN_FORPARSING,
                                            &path);
       DCHECK(SUCCEEDED(hr));
@@ skipping 310 matching lines @@
   return renderer_type;
 }
 
 HRESULT NavigateBrowserToMoniker(IUnknown* browser, IMoniker* moniker,
                                  const wchar_t* headers, IBindCtx* bind_ctx,
                                  const wchar_t* fragment, IStream* post_data) {
   DCHECK(browser);
   DCHECK(moniker);
   DCHECK(bind_ctx);
 
-  ScopedComPtr<IWebBrowser2> web_browser2;
+  base::win::ScopedComPtr<IWebBrowser2> web_browser2;
   HRESULT hr = DoQueryService(SID_SWebBrowserApp, browser,
                               web_browser2.Receive());
   DCHECK(web_browser2);
   DLOG_IF(WARNING, FAILED(hr)) << base::StringPrintf(L"SWebBrowserApp 0x%08X",
                                                      hr);
   if (FAILED(hr))
     return hr;
 
   // Always issue the download request in a new window to ensure that the
   // currently loaded ChromeFrame document does not inadvarently see an unload
@@ skipping 43 matching lines @@
   // is then used to determine if the moniker is already running and via
   // that mechanism is associated with the same internet request as has already
   // been issued.
 
   // TODO(tommi): See if we can get HlinkSimpleNavigateToMoniker to work
   // instead.  Looks like we'll need to support IHTMLDocument2 (get_URL in
   // particular), access to IWebBrowser2 etc.
   // HlinkSimpleNavigateToMoniker(moniker, url, NULL, host, bind_context,
   //                              NULL, 0, 0);
 
-  ScopedComPtr<IUriContainer> uri_container;
+  base::win::ScopedComPtr<IUriContainer> uri_container;
   hr = uri_container.QueryFrom(moniker);
 
   base::win::ScopedVariant headers_var;
   if (headers && headers[0])
     headers_var.Set(headers);
 
   if (uri_container) {
     // IE7 and IE8.
     const IID* interface_ids[] = {
       &IID_IWebBrowserPriv2IE7,
       &IID_IWebBrowserPriv2IE8,
       &IID_IWebBrowserPriv2IE8XP,
       &IID_IWebBrowserPriv2IE8XPBeta,
     };
 
-    ScopedComPtr<IWebBrowserPriv2Common, NULL> browser_priv2;
+    base::win::ScopedComPtr<IWebBrowserPriv2Common, NULL> browser_priv2;
     for (int i = 0; i < arraysize(interface_ids) && browser_priv2 == NULL;
          ++i) {
       hr = web_browser2.QueryInterface(*interface_ids[i],
           reinterpret_cast<void**>(browser_priv2.Receive()));
     }
 
     DCHECK(browser_priv2);
 
     if (browser_priv2) {
-      ScopedComPtr<IUri> uri_obj;
+      base::win::ScopedComPtr<IUri> uri_obj;
       uri_container->GetIUri(uri_obj.Receive());
       DCHECK(uri_obj);
 
       if (GetIEVersion() < IE_9) {
         hr = browser_priv2->NavigateWithBindCtx2(
                 uri_obj, &flags, NULL, post_data_variant.AsInput(),
                 headers_var.AsInput(), bind_ctx,
                 const_cast<wchar_t*>(fragment));
       } else {
         IWebBrowserPriv2CommonIE9* browser_priv2_ie9 =
             reinterpret_cast<IWebBrowserPriv2CommonIE9*>(browser_priv2.get());
         hr = browser_priv2_ie9->NavigateWithBindCtx2(
                 uri_obj, &flags, NULL, post_data_variant.AsInput(),
                 headers_var.AsInput(), bind_ctx,
                 const_cast<wchar_t*>(fragment), 0);
       }
       DLOG_IF(WARNING, FAILED(hr))
           << base::StringPrintf(L"NavigateWithBindCtx2 0x%08X", hr);
     }
   } else {
     // IE6
     LPOLESTR url = NULL;
     if (SUCCEEDED(hr = moniker->GetDisplayName(bind_ctx, NULL, &url))) {
       DVLOG(1) << __FUNCTION__ << " " << url;
-      ScopedComPtr<IWebBrowserPriv> browser_priv;
+      base::win::ScopedComPtr<IWebBrowserPriv> browser_priv;
       if (SUCCEEDED(hr = browser_priv.QueryFrom(web_browser2))) {
         GURL target_url(url);
         // On IE6 if the original URL has a fragment then the navigation
         // attempt is ignored. To workaround this we strip the fragment from
         // the url and initiate the navigation. When the active document loads
         // we retrieve the original url with the fragment from the Navigation
         // manager and use it.
         if (target_url.has_ref()) {
           url_parse::Component comp;
           GURL::Replacements replacements;
@@ skipping 87 matching lines @@
   }
 
   return buffer;
 }
 
 bool IsSubFrameRequest(IUnknown* service_provider) {
   DCHECK(service_provider);
 
   // We need to be able to get at an IWebBrowser2 if we are to decide whether
   // this request originates from a non-top-level frame.
-  ScopedComPtr<IWebBrowser2> web_browser;
+  base::win::ScopedComPtr<IWebBrowser2> web_browser;
   HRESULT hr = DoQueryService(IID_ITargetFrame2, service_provider,
                               web_browser.Receive());
 
   bool is_sub_frame_request = false;
   if (web_browser) {
     // Now check to see if we are in a sub-frame.
-    ScopedComPtr<IHTMLWindow2> current_frame, parent_frame;
+    base::win::ScopedComPtr<IHTMLWindow2> current_frame, parent_frame;
     hr = DoQueryService(IID_IHTMLWindow2, service_provider,
                         current_frame.Receive());
     if (current_frame) {
       // Only the top level window will return self when get_parent is called.
       current_frame->get_parent(parent_frame.Receive());
       if (parent_frame != current_frame) {
         DVLOG(1) << "Sub frame detected";
         is_sub_frame_request = true;
       }
     }
@@ skipping 132 matching lines @@
 
   return referrer;
 }
 
 std::string GetHttpHeadersFromBinding(IBinding* binding) {
   if (binding == NULL) {
     DLOG(WARNING) << "GetHttpResponseStatus - no binding_";
     return std::string();
   }
 
-  ScopedComPtr<IWinInetHttpInfo> info;
+  base::win::ScopedComPtr<IWinInetHttpInfo> info;
   if (FAILED(info.QueryFrom(binding))) {
     DLOG(WARNING) << "Failed to QI for IWinInetHttpInfo";
     return std::string();
   }
 
   return GetRawHttpHeaders(info);
 }
 
 int GetHttpResponseStatusFromBinding(IBinding* binding) {
   DVLOG(1) << __FUNCTION__;
   if (binding == NULL) {
     DLOG(WARNING) << "GetHttpResponseStatus - no binding_";
     return 0;
   }
 
   int http_status = 0;
 
-  ScopedComPtr<IWinInetHttpInfo> info;
+  base::win::ScopedComPtr<IWinInetHttpInfo> info;
   if (SUCCEEDED(info.QueryFrom(binding))) {
     char status[10] = {0};
     DWORD buf_size = sizeof(status);
     DWORD flags = 0;
     DWORD reserved = 0;
     if (SUCCEEDED(info->QueryInfo(HTTP_QUERY_STATUS_CODE, status, &buf_size,
                                   &flags, &reserved))) {
       base::StringToInt(status, &http_status);
     } else {
       NOTREACHED() << "Failed to get HTTP status";
@@ skipping 412 matching lines @@
   scoped_ptr<FileVersionInfo> module_version_info(
       FileVersionInfo::CreateFileVersionInfoForCurrentModule());
   DCHECK(module_version_info.get() != NULL);
   return module_version_info->file_version();
 }
 
 bool IsChromeFrameDocument(IWebBrowser2* web_browser) {
   if (!web_browser)
     return false;
 
-  ScopedComPtr<IDispatch> doc;
+  base::win::ScopedComPtr<IDispatch> doc;
   web_browser->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() != NULL;
   }
   return false;
 }
 
 bool IncreaseWinInetConnections(DWORD connections) {
   static bool wininet_connection_count_updated = false;
   if (wininet_connection_count_updated) {
     return true;
@@ skipping 19 matching lines @@
     ret = InternetSetOption(NULL, connection_options[option_index],
                             &connections, connection_value_size);
     if (!ret) {
       return false;
     }
   }
   wininet_connection_count_updated = true;
   return true;
 }