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

chrome_frame/buggy_bho_handling.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/buggy_bho_handling.h"
 
 #include "base/logging.h"
-#include "base/scoped_comptr_win.h"
+#include "base/win/scoped_comptr.h"
 
 #include "chrome_frame/exception_barrier.h"
 #include "chrome_frame/function_stub.h"
 #include "chrome_frame/utils.h"
 #include "chrome_frame/vtable_patch_manager.h"
 
 namespace buggy_bho {
 
 base::ThreadLocalPointer<BuggyBhoTls> BuggyBhoTls::s_bad_object_tls_;
 
@@ skipping 99 matching lines @@
   }
 }
 
 HRESULT BuggyBhoTls::PatchBuggyBHOs(IWebBrowser2* browser) {
   if (patched_)
     return S_FALSE;
 
   DCHECK(browser);
   DCHECK(web_browser2_ == NULL);
 
-  ScopedComPtr<IConnectionPointContainer> cpc;
+  base::win::ScopedComPtr<IConnectionPointContainer> cpc;
   HRESULT hr = cpc.QueryFrom(browser);
   if (SUCCEEDED(hr)) {
     const GUID sinks[] = { DIID_DWebBrowserEvents2, DIID_DWebBrowserEvents };
     for (size_t i = 0; i < arraysize(sinks); ++i) {
-      ScopedComPtr<IConnectionPoint> cp;
+      base::win::ScopedComPtr<IConnectionPoint> cp;
       cpc->FindConnectionPoint(sinks[i], cp.Receive());
       if (cp) {
-        ScopedComPtr<IEnumConnections> connections;
+        base::win::ScopedComPtr<IEnumConnections> connections;
         cp->EnumConnections(connections.Receive());
         if (connections) {
           CONNECTDATA cd = {0};
           DWORD fetched = 0;
           while (connections->Next(1, &cd, &fetched) == S_OK && fetched) {
             PatchIfBuggy(cd.pUnk, sinks[i]);
             cd.pUnk->Release();
             fetched = 0;
           }
         }
       }
     }
   }
   patched_ = true;
   web_browser2_ = browser;
   return hr;
 }
 
 bool BuggyBhoTls::PatchIfBuggy(IUnknown* unk, const IID& diid) {
   DCHECK(unk);
   PROC* methods = *reinterpret_cast<PROC**>(unk);
   HMODULE mod = GetModuleFromAddress(methods[0]);
   if (!IsBuggyBho(mod))
     return false;
 
-  ScopedComPtr<IDispatch> disp;
+  base::win::ScopedComPtr<IDispatch> disp;
   HRESULT hr = unk->QueryInterface(diid,
       reinterpret_cast<void**>(disp.Receive()));
   if (FAILED(hr))  // Sometimes only IDispatch QI is supported
     hr = disp.QueryFrom(unk);
   DCHECK(SUCCEEDED(hr));
 
   if (SUCCEEDED(hr)) {
     const int kInvokeIndex = 6;
     DCHECK(static_cast<IUnknown*>(disp) == unk);
     if (SUCCEEDED(PatchInvokeMethod(&methods[kInvokeIndex]))) {
@@ skipping 52 matching lines @@
     } else {
       PinModule();  // No backing out now.
       ::FlushInstructionCache(::GetCurrentProcess(), invoke, sizeof(PROC));
     }
   }
   ::VirtualProtect(invoke, sizeof(PROC), flags, &flags);
   return hr;
 }
 
 }  // end namespace buggy_bho