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

chrome_frame/protocol_sink_wrap.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 <htiframe.h>
 #include <mshtml.h>
 
 #include "chrome_frame/protocol_sink_wrap.h"
 
 #include "base/logging.h"
@@ skipping 78 matching lines @@
 base::Lock ProtData::datamap_lock_;
 
 ProtocolSinkWrap::ProtocolSinkWrap() {
   DVLOG(1) << __FUNCTION__ << base::StringPrintf(" 0x%08X", this);
 }
 
 ProtocolSinkWrap::~ProtocolSinkWrap() {
   DVLOG(1) << __FUNCTION__ << base::StringPrintf(" 0x%08X", this);
 }
 
-ScopedComPtr<IInternetProtocolSink> ProtocolSinkWrap::CreateNewSink(
+base::win::ScopedComPtr<IInternetProtocolSink> ProtocolSinkWrap::CreateNewSink(
     IInternetProtocolSink* sink, ProtData* data) {
   DCHECK(sink != NULL);
   DCHECK(data != NULL);
   CComObject<ProtocolSinkWrap>* new_sink = NULL;
   CComObject<ProtocolSinkWrap>::CreateInstance(&new_sink);
   new_sink->delegate_ = sink;
   new_sink->prot_data_ = data;
-  return ScopedComPtr<IInternetProtocolSink>(new_sink);
+  return base::win::ScopedComPtr<IInternetProtocolSink>(new_sink);
 }
 
 // IInternetProtocolSink methods
 STDMETHODIMP ProtocolSinkWrap::Switch(PROTOCOLDATA* protocol_data) {
   HRESULT hr = E_FAIL;
   if (delegate_)
     hr = delegate_->Switch(protocol_data);
   return hr;
 }
 
@@ skipping 22 matching lines @@
   DVLOG(1) << "ProtocolSinkWrap::ReportResult: result: " << result
            << " error: " << error
            << " Text: " << (result_text ? result_text : L"");
   ExceptionBarrier barrier;
   HRESULT hr = prot_data_->ReportResult(delegate_, result, error, result_text);
   return hr;
 }
 
 
 // Helpers
-ScopedComPtr<IBindCtx> BindCtxFromIBindInfo(IInternetBindInfo* bind_info) {
+base::win::ScopedComPtr<IBindCtx> BindCtxFromIBindInfo(
+    IInternetBindInfo* bind_info) {
   LPOLESTR bind_ctx_string = NULL;
   ULONG count;
-  ScopedComPtr<IBindCtx> bind_ctx;
+  base::win::ScopedComPtr<IBindCtx> bind_ctx;
   bind_info->GetBindString(BINDSTRING_PTR_BIND_CONTEXT, &bind_ctx_string, 1,
                            &count);
   if (bind_ctx_string) {
     int bind_ctx_int;
     base::StringToInt(bind_ctx_string, &bind_ctx_int);
     IBindCtx* pbc = reinterpret_cast<IBindCtx*>(bind_ctx_int);
     bind_ctx.Attach(pbc);
     CoTaskMemFree(bind_ctx_string);
   }
 
   return bind_ctx;
 }
 
 bool ShouldWrapSink(IInternetProtocolSink* sink, const wchar_t* url) {
   // Ignore everything that does not start with http:// or https://.
   // |url| is already normalized (i.e. no leading spaces, capital letters in
   // protocol etc) and non-null (we check in Hook_Start).
   DCHECK(url != NULL);
 
   if (ProtocolSinkWrap::ignore_xua())
     return false;  // No need to intercept, we're ignoring X-UA-Compatible tags
 
   if ((url != StrStrW(url, L"http://")) && (url != StrStrW(url, L"https://")))
     return false;
 
-  ScopedComPtr<IHttpNegotiate> http_negotiate;
+  base::win::ScopedComPtr<IHttpNegotiate> http_negotiate;
   HRESULT hr = DoQueryService(GUID_NULL, sink, http_negotiate.Receive());
   if (http_negotiate && !IsSubFrameRequest(http_negotiate))
     return true;
 
   return false;
 }
 
 // High level helpers
 bool IsCFRequest(IBindCtx* pbc) {
-  ScopedComPtr<BindContextInfo> info;
+  base::win::ScopedComPtr<BindContextInfo> info;
   BindContextInfo::FromBindContext(pbc, info.Receive());
   if (info && info->chrome_request())
     return true;
 
   return false;
 }
 
 bool HasProtData(IBindCtx* pbc) {
-  ScopedComPtr<BindContextInfo> info;
+  base::win::ScopedComPtr<BindContextInfo> info;
   BindContextInfo::FromBindContext(pbc, info.Receive());
   bool result = false;
   if (info)
     result = info->has_prot_data();
   return result;
 }
 
 void PutProtData(IBindCtx* pbc, ProtData* data) {
   // AddRef and Release to avoid a potential leak of a ProtData instance if
   // FromBindContext fails.
   data->AddRef();
-  ScopedComPtr<BindContextInfo> info;
+  base::win::ScopedComPtr<BindContextInfo> info;
   BindContextInfo::FromBindContext(pbc, info.Receive());
   if (info)
     info->set_prot_data(data);
   data->Release();
 }
 
 bool IsTextHtml(const wchar_t* status_text) {
   const std::wstring str = status_text;
   bool is_text_html = LowerCaseEqualsASCII(str, kTextHtmlMimeType);
   return is_text_html;
@@ skipping 190 matching lines @@
     case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
       SaveSuggestedMimeType(status_text);
       // When Transaction is attached i.e. when existing BTS it terminated
       // and "converted" to BTO, events will be re-fired for the new sink,
       // but we may skip the renderer_type_ determination since it's already
       // done.
       if (renderer_type_ == RENDERER_TYPE_UNDETERMINED) {
         // This may seem awkward. CBinding's implementation of IWinInetHttpInfo
         // will forward to CTransaction that will forward to the real protocol.
         // We may ask CTransaction (our protocol_ member) for IWinInetHttpInfo.
-        ScopedComPtr<IWinInetHttpInfo> info;
+        base::win::ScopedComPtr<IWinInetHttpInfo> info;
         info.QueryFrom(delegate);
         renderer_type_ = DetermineRendererTypeFromMetaData(suggested_mime_type_,
                                                            url_, info);
       }
 
       if (IsChrome(renderer_type_)) {
         // Suggested mime type is "text/html" and we have DEFAULT_RENDERER,
         // OPT_IN_URL, or RESPONSE_HEADER.
         DVLOG(1) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
                  << kChromeMimeType;
@@ skipping 113 matching lines @@
   if (has_suggested_mime_type_) {
     DVLOG(1) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
              << suggested_mime_type_;
     delegate->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE,
                              suggested_mime_type_);
   }
 }
 
 void ProtData::SaveReferrer(IInternetProtocolSink* delegate) {
   DCHECK(IsChrome(renderer_type_));
-  ScopedComPtr<IWinInetHttpInfo> info;
+  base::win::ScopedComPtr<IWinInetHttpInfo> info;
   info.QueryFrom(delegate);
   if (info) {
     char buffer[4096] = {0};
     DWORD len = sizeof(buffer);
     DWORD flags = 0;
     HRESULT hr = info->QueryInfo(
         HTTP_QUERY_REFERER | HTTP_QUERY_FLAG_REQUEST_HEADERS,
         buffer, &len, &flags, 0);
     if (hr == S_OK && len > 0)
       referrer_.assign(buffer);
@@ skipping 71 matching lines @@
 
 // IInternetProtocol/Ex hooks.
 STDMETHODIMP Hook_Start(InternetProtocol_Start_Fn orig_start,
     IInternetProtocol* protocol, LPCWSTR url, IInternetProtocolSink* prot_sink,
     IInternetBindInfo* bind_info, DWORD flags, HANDLE_PTR reserved) {
   DCHECK(orig_start);
   if (!url || !prot_sink || !bind_info)
     return E_INVALIDARG;
   DVLOG_IF(1, url != NULL) << "OnStart: " << url << PiFlags2Str(flags);
 
-  ScopedComPtr<IBindCtx> bind_ctx = BindCtxFromIBindInfo(bind_info);
+  base::win::ScopedComPtr<IBindCtx> bind_ctx = BindCtxFromIBindInfo(bind_info);
   if (!bind_ctx) {
     // MSHTML sometimes takes a short path, skips the creation of
     // moniker and binding, by directly grabbing protocol from InternetSession
     DVLOG(1) << "DirectBind for " << url;
     return ForwardHookStart(orig_start, protocol, url, prot_sink, bind_info,
                             flags, reserved);
   }
 
   scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
   if (prot_data && !HasProtData(bind_ctx)) {
     prot_data->Invalidate();
     prot_data = NULL;
   }
 
   if (HandleAttachToExistingExternalTab(url, protocol, prot_sink, bind_ctx)) {
     return S_OK;
   }
 
   if (IsCFRequest(bind_ctx)) {
-    ScopedComPtr<BindContextInfo> info;
+    base::win::ScopedComPtr<BindContextInfo> info;
     BindContextInfo::FromBindContext(bind_ctx, info.Receive());
     DCHECK(info);
     if (info) {
       info->set_protocol(protocol);
     }
     return ForwardHookStart(orig_start, protocol, url, prot_sink, bind_info,
                             flags, reserved);
   }
 
   if (prot_data) {
     DVLOG(1) << "Found existing ProtData!";
     prot_data->UpdateUrl(url);
-    ScopedComPtr<IInternetProtocolSink> new_sink =
+    base::win::ScopedComPtr<IInternetProtocolSink> new_sink =
         ProtocolSinkWrap::CreateNewSink(prot_sink, prot_data);
     return ForwardWrappedHookStart(orig_start, protocol, url, new_sink,
                                    bind_info, flags, reserved);
   }
 
   if (!ShouldWrapSink(prot_sink, url)) {
     return ForwardHookStart(orig_start, protocol, url, prot_sink, bind_info,
                             flags, reserved);
   }
 
   // Fresh request.
   InternetProtocol_Read_Fn read_fun = reinterpret_cast<InternetProtocol_Read_Fn>
       (CTransaction_PatchInfo[1].stub_->argument());
   prot_data = new ProtData(protocol, read_fun, url);
   PutProtData(bind_ctx, prot_data);
 
-  ScopedComPtr<IInternetProtocolSink> new_sink =
+  base::win::ScopedComPtr<IInternetProtocolSink> new_sink =
       ProtocolSinkWrap::CreateNewSink(prot_sink, prot_data);
   return ForwardWrappedHookStart(orig_start, protocol, url, new_sink, bind_info,
                                  flags, reserved);
 }
 
 HRESULT ForwardHookStartEx(InternetProtocol_StartEx_Fn orig_start_ex,
     IInternetProtocolEx* protocol, IUri* uri, IInternetProtocolSink* prot_sink,
     IInternetBindInfo* bind_info, DWORD flags, HANDLE_PTR reserved) {
   ExceptionBarrierReportOnlyModule barrier;
   return orig_start_ex(protocol, uri, prot_sink, bind_info, flags, reserved);
@@ skipping 10 matching lines @@
     IInternetProtocolEx* protocol, IUri* uri, IInternetProtocolSink* prot_sink,
     IInternetBindInfo* bind_info, DWORD flags, HANDLE_PTR reserved) {
   DCHECK(orig_start_ex);
   if (!uri || !prot_sink || !bind_info)
     return E_INVALIDARG;
 
   base::win::ScopedBstr url;
   uri->GetPropertyBSTR(Uri_PROPERTY_ABSOLUTE_URI, url.Receive(), 0);
   DVLOG_IF(1, url != NULL) << "OnStartEx: " << url << PiFlags2Str(flags);
 
-  ScopedComPtr<IBindCtx> bind_ctx = BindCtxFromIBindInfo(bind_info);
+  base::win::ScopedComPtr<IBindCtx> bind_ctx = BindCtxFromIBindInfo(bind_info);
   if (!bind_ctx) {
     // MSHTML sometimes takes a short path, skips the creation of
     // moniker and binding, by directly grabbing protocol from InternetSession.
     DVLOG(1) << "DirectBind for " << url;
     return ForwardHookStartEx(orig_start_ex, protocol, uri, prot_sink,
                               bind_info, flags, reserved);
   }
 
   scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
   if (prot_data && !HasProtData(bind_ctx)) {
     prot_data->Invalidate();
     prot_data = NULL;
   }
 
   if (HandleAttachToExistingExternalTab(url, protocol, prot_sink, bind_ctx)) {
     return S_OK;
   }
 
   if (IsCFRequest(bind_ctx)) {
-    ScopedComPtr<BindContextInfo> info;
+    base::win::ScopedComPtr<BindContextInfo> info;
     BindContextInfo::FromBindContext(bind_ctx, info.Receive());
     DCHECK(info);
     if (info) {
       info->set_protocol(protocol);
     }
     return ForwardHookStartEx(orig_start_ex, protocol, uri, prot_sink,
                               bind_info, flags, reserved);
   }
 
   if (prot_data) {
     DVLOG(1) << "Found existing ProtData!";
     prot_data->UpdateUrl(url);
-    ScopedComPtr<IInternetProtocolSink> new_sink =
+    base::win::ScopedComPtr<IInternetProtocolSink> new_sink =
         ProtocolSinkWrap::CreateNewSink(prot_sink, prot_data);
     return ForwardWrappedHookStartEx(orig_start_ex, protocol, uri, new_sink,
                                      bind_info, flags, reserved);
   }
 
   if (!ShouldWrapSink(prot_sink, url)) {
     return ForwardHookStartEx(orig_start_ex, protocol, uri, prot_sink,
                               bind_info, flags, reserved);
   }
 
   // Fresh request.
   InternetProtocol_Read_Fn read_fun = reinterpret_cast<InternetProtocol_Read_Fn>
     (CTransaction_PatchInfo[1].stub_->argument());
   prot_data = new ProtData(protocol, read_fun, url);
   PutProtData(bind_ctx, prot_data);
 
-  ScopedComPtr<IInternetProtocolSink> new_sink =
+  base::win::ScopedComPtr<IInternetProtocolSink> new_sink =
       ProtocolSinkWrap::CreateNewSink(prot_sink, prot_data);
   return ForwardWrappedHookStartEx(orig_start_ex, protocol, uri, new_sink,
                                    bind_info, flags, reserved);
 }
 
 STDMETHODIMP Hook_Read(InternetProtocol_Read_Fn orig_read,
     IInternetProtocol* protocol, void* buffer, ULONG size, ULONG* size_read) {
   DCHECK(orig_read);
   HRESULT hr = E_FAIL;
 
@@ skipping 68 matching lines @@
   STDMETHOD(Abort)(HRESULT reason, DWORD options) { return S_OK; }
   STDMETHOD(Terminate)(DWORD options) { return S_OK; }
   STDMETHOD(Suspend)() { return S_OK; }
   STDMETHOD(Resume)() { return S_OK; }
   STDMETHOD(Read)(void *buffer, ULONG size, ULONG* size_read) { return S_OK; }
   STDMETHOD(Seek)(LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER* new_pos)
     { return S_OK; }
   STDMETHOD(LockRequest)(DWORD options) { return S_OK; }
   STDMETHOD(UnlockRequest)() { return S_OK; }
 
-  ScopedComPtr<IInternetProtocol> transaction_;
+  base::win::ScopedComPtr<IInternetProtocol> transaction_;
 };
 
 struct FakeFactory : public IClassFactory,
                      public CComObjectRootEx<CComSingleThreadModel> {
   BEGIN_COM_MAP(FakeFactory)
     COM_INTERFACE_ENTRY(IClassFactory)
   END_COM_MAP()
 
   STDMETHOD(CreateInstance)(IUnknown *pUnkOuter, REFIID riid, void **ppvObj) {
     if (pUnkOuter)
       return CLASS_E_NOAGGREGATION;
     HRESULT hr = obj_->QueryInterface(riid, ppvObj);
     return hr;
   }
 
   STDMETHOD(LockServer)(BOOL fLock) {
     return S_OK;
   }
 
   IUnknown* obj_;
 };
 
 static void HookTransactionVtable(IInternetProtocol* p) {
-  ScopedComPtr<IInternetProtocolEx> ex;
+  base::win::ScopedComPtr<IInternetProtocolEx> ex;
   ex.QueryFrom(p);
 
   HRESULT hr = vtable_patch::PatchInterfaceMethods(p, CTransaction_PatchInfo);
   if (hr == S_OK && ex) {
     vtable_patch::PatchInterfaceMethods(ex.get(), CTransaction2_PatchInfo);
   }
 }
 
 void TransactionHooks::InstallHooks() {
   if (IS_PATCHED(CTransaction)) {
     DLOG(WARNING) << __FUNCTION__ << " called more than once.";
     return;
   }
 
   CComObjectStackEx<FakeProtocol> prot;
   CComObjectStackEx<FakeFactory> factory;
   factory.obj_ = &prot;
-  ScopedComPtr<IInternetSession> session;
+  base::win::ScopedComPtr<IInternetSession> session;
   HRESULT hr = ::CoInternetGetSession(0, session.Receive(), 0);
   hr = session->RegisterNameSpace(&factory, CLSID_NULL, L"611", 0, 0, 0);
   DLOG_IF(FATAL, FAILED(hr)) << "Failed to register namespace";
   if (hr != S_OK)
     return;
 
   do {
-    ScopedComPtr<IMoniker> mk;
-    ScopedComPtr<IBindCtx> bc;
-    ScopedComPtr<IStream> stream;
+    base::win::ScopedComPtr<IMoniker> mk;
+    base::win::ScopedComPtr<IBindCtx> bc;
+    base::win::ScopedComPtr<IStream> stream;
     hr = ::CreateAsyncBindCtxEx(0, 0, 0, 0, bc.Receive(), 0);
     DLOG_IF(FATAL, FAILED(hr)) << "CreateAsyncBindCtxEx failed " << hr;
     if (hr != S_OK)
       break;
 
     hr = ::CreateURLMoniker(NULL, L"611://512", mk.Receive());
     DLOG_IF(FATAL, FAILED(hr)) << "CreateURLMoniker failed " << hr;
     if (hr != S_OK)
       break;
 
     hr = mk->BindToStorage(bc, NULL, IID_IStream,
                            reinterpret_cast<void**>(stream.Receive()));
     DLOG_IF(FATAL, hr != INET_E_INVALID_CERTIFICATE) <<
         "BindToStorage failed " << hr;
   } while (0);
 
   hr = session->UnregisterNameSpace(&factory, L"611");
   if (prot.transaction_) {
     HookTransactionVtable(prot.transaction_);
     // Explicit release, otherwise ~CComObjectStackEx will complain about
     // outstanding reference to us, because it runs before ~FakeProtocol
     prot.transaction_.Release();
   }
 }
 
 void TransactionHooks::RevertHooks() {
   vtable_patch::UnpatchInterfaceMethods(CTransaction_PatchInfo);
   vtable_patch::UnpatchInterfaceMethods(CTransaction2_PatchInfo);
 }