ceee: Include base/win/scope_comptr.h instead of base/scoped_comptr_win.h

ceee/ie/plugin/bho/http_negotiate.cc

 // Copyright (c) 2010 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 "ceee/ie/plugin/bho/http_negotiate.h"
 
 #include <atlbase.h>
 #include <atlctl.h>
 #include <htiframe.h>
 #include <urlmon.h>
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/time.h"
-
+#include "base/win/scoped_comptr.h"
 #include "ceee/ie/plugin/bho/cookie_accountant.h"
 #include "chrome_frame/vtable_patch_manager.h"
 #include "chrome_frame/utils.h"
-#include "base/scoped_comptr_win.h"
 
 static const int kHttpNegotiateBeginningTransactionIndex = 3;
 static const int kHttpNegotiateOnResponseIndex = 4;
 
 CComAutoCriticalSection HttpNegotiatePatch::bho_instance_count_crit_;
 int HttpNegotiatePatch::bho_instance_count_ = 0;
 
 
 BEGIN_VTABLE_PATCHES(IHttpNegotiate)
   VTABLE_PATCH_ENTRY(kHttpNegotiateBeginningTransactionIndex,
@@ skipping 64 matching lines @@
   }
 
   if (IS_PATCHED(IHttpNegotiate)) {
     LOG(WARNING) << __FUNCTION__ << ": already patched.";
     return true;
   }
 
   // Use our SimpleBindStatusCallback class as we need a temporary object that
   // implements IBindStatusCallback.
   CComObjectStackEx<SimpleBindStatusCallback> request;
-  ScopedComPtr<IBindCtx> bind_ctx;
+  base::win::ScopedComPtr<IBindCtx> bind_ctx;
   HRESULT hr = ::CreateAsyncBindCtx(0, &request, NULL, bind_ctx.Receive());
 
   DCHECK(SUCCEEDED(hr)) << "CreateAsyncBindCtx";
   if (bind_ctx) {
-    ScopedComPtr<IUnknown> bscb_holder;
+    base::win::ScopedComPtr<IUnknown> bscb_holder;
     bind_ctx->GetObjectParam(L"_BSCB_Holder_", bscb_holder.Receive());
     if (bscb_holder) {
       hr = PatchHttpNegotiate(bscb_holder);
     } else {
       NOTREACHED() << "Failed to get _BSCB_Holder_";
       hr = E_UNEXPECTED;
     }
     bind_ctx.Release();
   }
 
   return SUCCEEDED(hr);
 }
 
 // static
 void HttpNegotiatePatch::Uninitialize() {
   CComCritSecLock<CComAutoCriticalSection> lock(bho_instance_count_crit_);
   bho_instance_count_--;
   DCHECK_GE(bho_instance_count_, 0);
   if (bho_instance_count_ == 0) {
     vtable_patch::UnpatchInterfaceMethods(IHttpNegotiate_PatchInfo);
   }
 }
 
 // static
 HRESULT HttpNegotiatePatch::PatchHttpNegotiate(IUnknown* to_patch) {
   DCHECK(to_patch);
   DCHECK_IS_NOT_PATCHED(IHttpNegotiate);
 
-  ScopedComPtr<IHttpNegotiate> http;
+  base::win::ScopedComPtr<IHttpNegotiate> http;
   HRESULT hr = http.QueryFrom(to_patch);
   if (FAILED(hr)) {
     hr = DoQueryService(IID_IHttpNegotiate, to_patch, http.Receive());
   }
 
   if (http) {
     hr = vtable_patch::PatchInterfaceMethods(http, IHttpNegotiate_PatchInfo);
     DLOG_IF(ERROR, FAILED(hr))
         << StringPrintf("HttpNegotiate patch failed 0x%08X", hr);
   } else {
@@ skipping 38 matching lines @@
   if (FAILED(hr)) {
     DLOG(WARNING) << __FUNCTION__ << " Delegate returned an error";
     return hr;
   }
 
   CookieAccountant::GetInstance()->RecordHttpResponseCookies(
     std::string(CW2A(response_headers)), current_time);
 
   return hr;
 }