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

chrome_frame/urlmon_url_request.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/urlmon_url_request.h"
 
+#include <urlmon.h>
 #include <wininet.h>
-#include <urlmon.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/common/automation_messages.h"
 #include "chrome_frame/bind_context_info.h"
 #include "chrome_frame/chrome_frame_activex_base.h"
 #include "chrome_frame/extra_system_apis.h"
 #include "chrome_frame/html_utils.h"
+#include "chrome_frame/urlmon_upload_data_stream.h"
 #include "chrome_frame/urlmon_url_request_private.h"
-#include "chrome_frame/urlmon_upload_data_stream.h"
 #include "chrome_frame/utils.h"
-#include "chrome/common/automation_messages.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 
 UrlmonUrlRequest::UrlmonUrlRequest()
     : pending_read_size_(0),
       headers_received_(false),
       calling_delegate_(0),
       thread_(NULL),
       parent_window_(NULL),
@@ skipping 143 matching lines @@
     terminate_bind_callback_.reset(callback);
     if (pending_data_) {
       // For downloads to work correctly, we must induce a call to
       // OnDataAvailable so that we can download INET_E_TERMINATED_BIND and
       // get IE into the correct state.
       // To accomplish this we read everything that's readily available in
       // the current stream.  Once we've reached the end of the stream we
       // should get E_PENDING back and then later we'll get that call
       // to OnDataAvailable.
       std::string data;
-      ScopedComPtr<IStream> read_stream(pending_data_);
+      base::win::ScopedComPtr<IStream> read_stream(pending_data_);
       HRESULT hr;
       while ((hr = ReadStream(read_stream, 0xffff, &data)) == S_OK) {
         // Just drop the data.
       }
       DLOG_IF(WARNING, hr != E_PENDING) << __FUNCTION__ <<
           base::StringPrintf(" expected E_PENDING but got 0x%08X", hr);
     }
   }
 }
 
@@ skipping 13 matching lines @@
     }
 
     if (read_data.empty() && pending_data_) {
       size_t pending_data_read_save = pending_read_size_;
       pending_read_size_ = 0;
 
       // AddRef the stream while we call Read to avoid a potential issue
       // where we can get a call to OnDataAvailable while inside Read and
       // in our OnDataAvailable call, we can release the stream object
       // while still using it.
-      ScopedComPtr<IStream> pending(pending_data_);
+      base::win::ScopedComPtr<IStream> pending(pending_data_);
       HRESULT hr = ReadStream(pending, bytes_to_read, &read_data);
       if (read_data.empty())
         pending_read_size_ = pending_data_read_save;
       // If we received S_FALSE it indicates that there is no more data in the
       // stream. Clear it to ensure that OnStopBinding correctly sends over the
       // response end notification to chrome.
       if (hr == S_FALSE)
         pending_data_.Release();
     }
 
@@ skipping 58 matching lines @@
       if (status_text) {
         socket_address_.set_host(WideToUTF8(status_text));
       }
       break;
     }
 
     case BINDSTATUS_REDIRECTING: {
       // If we receive a redirect for the initial pending request initiated
       // when our document loads we should stash it away and inform Chrome
       // accordingly when it requests data for the original URL.
-      ScopedComPtr<BindContextInfo> info;
+      base::win::ScopedComPtr<BindContextInfo> info;
       BindContextInfo::FromBindContext(bind_context_, info.Receive());
       DCHECK(info);
       GURL previously_redirected(info ? info->GetUrl() : std::wstring());
       if (GURL(status_text) != previously_redirected) {
         DVLOG(1) << __FUNCTION__ << me() << "redirect from " << url()
                  << " to " << status_text;
         // Fetch the redirect status as they aren't all equal (307 in particular
         // retains the HTTP request verb).
         int http_code = GetHttpResponseStatusFromBinding(binding_);
         status_.SetRedirected(http_code, WideToUTF8(status_text));
@@ skipping 486 matching lines @@
     hr = ::CreateAsyncBindCtxEx(NULL, 0, this, NULL,
                                 bind_context_.Receive(), 0);
     DCHECK(SUCCEEDED(hr)) << "CreateAsyncBindCtxEx failed. Error: " << hr;
   } else {
     // Use existing bind context.
     hr = ::RegisterBindStatusCallback(bind_context_, this, NULL, 0);
     DCHECK(SUCCEEDED(hr)) << "RegisterBindStatusCallback failed. Error: " << hr;
   }
 
   if (SUCCEEDED(hr)) {
-    ScopedComPtr<IStream> stream;
+    base::win::ScopedComPtr<IStream> stream;
 
     // BindToStorage may complete synchronously.
     // We still get all the callbacks - OnStart/StopBinding, this may result
     // in destruction of our object. It's fine but we access some members
     // below for debug info. :)
-    ScopedComPtr<IHttpSecurity> self(this);
+    base::win::ScopedComPtr<IHttpSecurity> self(this);
 
     // Inform our moniker patch this binding should not be tortured.
-    ScopedComPtr<BindContextInfo> info;
+    base::win::ScopedComPtr<BindContextInfo> info;
     BindContextInfo::FromBindContext(bind_context_, info.Receive());
     DCHECK(info);
     if (info)
       info->set_chrome_request(true);
 
     hr = moniker_->BindToStorage(bind_context_, NULL, __uuidof(IStream),
                                  reinterpret_cast<void**>(stream.Receive()));
     if (hr == S_OK)
       DCHECK(binding_ != NULL || status_.get_state() == Status::DONE);
 
@@ skipping 36 matching lines @@
     // We return INET_E_TERMINATED_BIND from our OnDataAvailable implementation
     // to ensure that the transaction stays around if Chrome decides to issue
     // a download request when it finishes inspecting the headers received in
     // OnResponse. However this causes the urlmon transaction object to leak.
     // To workaround this we save away the IInternetProtocol interface which is
     // implemented by the urlmon CTransaction object in our BindContextInfo
     // instance which is maintained per bind context. Invoking Terminate
     // on this with the special flags 0x2000000 cleanly releases the
     // transaction.
     static const int kUrlmonTerminateTransactionFlags = 0x2000000;
-    ScopedComPtr<BindContextInfo> info;
+    base::win::ScopedComPtr<BindContextInfo> info;
     BindContextInfo::FromBindContext(bind_context_, info.Receive());
     DCHECK(info);
     if (info && info->protocol()) {
       info->protocol()->Terminate(kUrlmonTerminateTransactionFlags);
     }
   }
   bind_context_.Release();
 }
 
 void UrlmonUrlRequest::ReleaseBindings() {
@@ skipping 72 matching lines @@
 
 void UrlmonUrlRequestManager::SetInfoForUrl(const std::wstring& url,
                                             IMoniker* moniker, LPBC bind_ctx) {
   CComObject<UrlmonUrlRequest>* new_request = NULL;
   CComObject<UrlmonUrlRequest>::CreateInstance(&new_request);
   if (new_request) {
     GURL start_url(url);
     DCHECK(start_url.is_valid());
     DCHECK(pending_request_ == NULL);
 
-    ScopedComPtr<BindContextInfo> info;
+    base::win::ScopedComPtr<BindContextInfo> info;
     BindContextInfo::FromBindContext(bind_ctx, info.Receive());
     DCHECK(info);
     IStream* cache = info ? info->cache() : NULL;
     pending_request_ = new_request;
     pending_request_->InitPending(start_url, moniker, bind_ctx,
                                   enable_frame_busting_, privileged_mode_,
                                   notification_window_, cache);
     // Start the request
     bool is_started = pending_request_->Start();
     DCHECK(is_started);
@@ skipping 279 matching lines @@
       privacy_info_.privacy_records[UTF8ToWide(url)];
 
   privacy_entry.flags |= flags;
   privacy_entry.policy_ref = UTF8ToWide(policy_ref);
 
   if (fire_privacy_event && IsWindow(notification_window_)) {
     PostMessage(notification_window_, WM_FIRE_PRIVACY_CHANGE_NOTIFICATION, 1,
                 0);
   }
 }