Move platform_thread to base/threading and put in the base namespace. I left ...

chrome_frame/urlmon_url_request.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 "chrome_frame/urlmon_url_request.h"
 
 #include <wininet.h>
 #include <urlmon.h>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.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_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_url_request_private.h"
 #include "chrome_frame/urlmon_upload_data_stream.h"
 #include "chrome_frame/utils.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_util.h"
@@ skipping 15 matching lines @@
 UrlmonUrlRequest::~UrlmonUrlRequest() {
   DVLOG(1) << __FUNCTION__ << me();
 }
 
 std::string UrlmonUrlRequest::me() const {
   return base::StringPrintf(" id: %i Obj: %X ", id(), this);
 }
 
 bool UrlmonUrlRequest::Start() {
   DVLOG(1) << __FUNCTION__ << me() << url();
-  DCHECK(thread_ == 0 || thread_ == PlatformThread::CurrentId());
-  thread_ = PlatformThread::CurrentId();
+  DCHECK(thread_ == 0 || thread_ == base::PlatformThread::CurrentId());
+  thread_ = base::PlatformThread::CurrentId();
   status_.Start();
   // The UrlmonUrlRequest instance can get destroyed in the context of
   // StartAsyncDownload if BindToStorage finishes synchronously with an error.
   // Grab a reference to protect against this.
   scoped_refptr<UrlmonUrlRequest> ref(this);
   HRESULT hr = StartAsyncDownload();
   if (FAILED(hr) && status_.get_state() != UrlmonUrlRequest::Status::DONE) {
     status_.Done();
     status_.set_result(URLRequestStatus::FAILED, HresultToNetError(hr));
     NotifyDelegateAndDie();
   }
   return true;
 }
 
 void UrlmonUrlRequest::Stop() {
-  DCHECK_EQ(thread_, PlatformThread::CurrentId());
+  DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   DCHECK((status_.get_state() != Status::DONE) == (binding_ != NULL));
   Status::State state = status_.get_state();
   delegate_ = NULL;
 
   // If DownloadInHost is already requested, we will quit soon anyway.
   if (terminate_requested())
     return;
 
   switch (state) {
     case Status::WORKING:
       status_.Cancel();
       if (binding_)
         binding_->Abort();
       break;
 
     case Status::ABORTING:
       status_.Cancel();
       break;
 
     case Status::DONE:
       status_.Cancel();
       NotifyDelegateAndDie();
       break;
   }
 }
 
 bool UrlmonUrlRequest::Read(int bytes_to_read) {
-  DCHECK_EQ(thread_, PlatformThread::CurrentId());
+  DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   DCHECK_GE(bytes_to_read, 0);
   DCHECK_EQ(0, calling_delegate_);
   DVLOG(1) << __FUNCTION__ << me();
 
   is_expecting_download_ = false;
 
   // Re-entrancy check. Thou shall not call Read() while process OnReadComplete!
   DCHECK_EQ(0u, pending_read_size_);
   if (pending_read_size_ != 0)
     return false;
@@ skipping 23 matching lines @@
 HRESULT UrlmonUrlRequest::InitPending(const GURL& url, IMoniker* moniker,
                                       IBindCtx* bind_context,
                                       bool enable_frame_busting,
                                       bool privileged_mode,
                                       HWND notification_window,
                                       IStream* cache) {
   DVLOG(1) << __FUNCTION__ << me() << url.spec();
   DCHECK(bind_context_ == NULL);
   DCHECK(moniker_ == NULL);
   DCHECK(cache_ == NULL);
-  DCHECK(thread_ == 0 || thread_ == PlatformThread::CurrentId());
-  thread_ = PlatformThread::CurrentId();
+  DCHECK(thread_ == 0 || thread_ == base::PlatformThread::CurrentId());
+  thread_ = base::PlatformThread::CurrentId();
   bind_context_ = bind_context;
   moniker_ = moniker;
   enable_frame_busting_ = enable_frame_busting;
   privileged_mode_ = privileged_mode;
   parent_window_ = notification_window;
   cache_ = cache;
   set_url(url.spec());
   set_pending(true);
 
   // Request has already started and data is fetched. We will get the
   // GetBindInfo call as per contract but the return values are
   // ignored. So just set "get" as a method to make our GetBindInfo
   // implementation happy.
   method_ = "get";
   return S_OK;
 }
 
 void UrlmonUrlRequest::TerminateBind(TerminateBindCallback* callback) {
-  DCHECK_EQ(thread_, PlatformThread::CurrentId());
+  DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   DVLOG(1) << __FUNCTION__ << me();
   cleanup_transaction_ = false;
   if (status_.get_state() == Status::DONE) {
     // Binding is stopped. Note result could be an error.
     callback->Run(moniker_, bind_context_);
     delete callback;
   } else {
     // WORKING (ABORTING?). Save the callback.
     // Now we will return INET_TERMINATE_BIND from ::OnDataAvailable() and in
     // ::OnStopBinding will invoke the callback passing our moniker and
@@ skipping 13 matching lines @@
       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);
     }
   }
 }
 
 size_t UrlmonUrlRequest::SendDataToDelegate(size_t bytes_to_read) {
-  DCHECK_EQ(thread_, PlatformThread::CurrentId());
+  DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   DCHECK_NE(id(), -1);
   DCHECK_GT(bytes_to_read, 0U);
   size_t bytes_copied = 0;
   if (delegate_) {
     std::string read_data;
     if (cache_) {
       HRESULT hr = ReadStream(cache_, bytes_to_read, &read_data);
       if (hr == S_FALSE || read_data.length() < bytes_to_read) {
         DVLOG(1) << __FUNCTION__ << me() << "all cached data read";
         cache_.Release();
@@ skipping 31 matching lines @@
     }
   } else {
     DLOG(ERROR) << __FUNCTION__ << me() << "no delegate";
   }
 
   return bytes_copied;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnStartBinding(DWORD reserved,
                                               IBinding* binding) {
-  DCHECK_EQ(thread_, PlatformThread::CurrentId());
+  DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   binding_ = binding;
   if (pending_) {
     response_headers_ = GetHttpHeadersFromBinding(binding_);
     DCHECK(!response_headers_.empty());
   }
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::GetPriority(LONG *priority) {
   if (!priority)
     return E_POINTER;
   *priority = THREAD_PRIORITY_NORMAL;
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnLowResource(DWORD reserved) {
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnProgress(ULONG progress, ULONG max_progress,
     ULONG status_code, LPCWSTR status_text) {
-  DCHECK_EQ(thread_, PlatformThread::CurrentId());
+  DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
 
   if (status_.get_state() != Status::WORKING)
     return S_OK;
 
   // Ignore any notifications received while we are in the pending state
   // waiting for the request to be initiated by Chrome.
   if (pending_ && status_code != BINDSTATUS_REDIRECTING)
     return S_OK;
 
   if (!delegate_) {
@@ skipping 56 matching lines @@
       DVLOG(1) << __FUNCTION__ << me()
                << base::StringPrintf(L"code: %i status: %ls", status_code,
                                      status_text);
       break;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnStopBinding(HRESULT result, LPCWSTR error) {
-  DCHECK_EQ(thread_, PlatformThread::CurrentId());
+  DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   DVLOG(1) << __FUNCTION__ << me()
            << "- Request stopped, Result: " << std::hex << result;
   DCHECK(status_.get_state() == Status::WORKING ||
          status_.get_state() == Status::ABORTING);
 
   Status::State state = status_.get_state();
 
   // Mark we a are done.
   status_.Done();
 
@@ skipping 123 matching lines @@
       DVLOG(1) << __FUNCTION__ << me() << "POST request with no data!";
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnDataAvailable(DWORD flags, DWORD size,
                                                FORMATETC* formatetc,
                                                STGMEDIUM* storage) {
-  DCHECK_EQ(thread_, PlatformThread::CurrentId());
+  DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   DVLOG(1) << __FUNCTION__ << me() << "bytes available: " << size;
 
   if (terminate_requested()) {
     DVLOG(1) << " Download requested. INET_E_TERMINATED_BIND returned";
     return INET_E_TERMINATED_BIND;
   }
 
   if (!storage || (storage->tymed != TYMED_ISTREAM)) {
     NOTREACHED();
     return E_INVALIDARG;
@@ skipping 32 matching lines @@
 STDMETHODIMP UrlmonUrlRequest::OnObjectAvailable(REFIID iid, IUnknown* object) {
   // We are calling BindToStorage on the moniker we should always get called
   // back on OnDataAvailable and should never get OnObjectAvailable
   NOTREACHED();
   return E_NOTIMPL;
 }
 
 STDMETHODIMP UrlmonUrlRequest::BeginningTransaction(const wchar_t* url,
     const wchar_t* current_headers, DWORD reserved,
     wchar_t** additional_headers) {
-  DCHECK_EQ(thread_, PlatformThread::CurrentId());
+  DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   if (!additional_headers) {
     NOTREACHED();
     return E_POINTER;
   }
 
   DVLOG(1) << __FUNCTION__ << me() << "headers: \n" << current_headers;
 
   if (status_.get_state() == Status::ABORTING) {
     // At times the BINDSTATUS_REDIRECTING notification which is sent to the
     // IBindStatusCallback interface does not have an accompanying HTTP
@@ skipping 55 matching lines @@
                 new_headers.size());
     }
   }
 
   return hr;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnResponse(DWORD dwResponseCode,
     const wchar_t* response_headers, const wchar_t* request_headers,
     wchar_t** additional_headers) {
-  DCHECK_EQ(thread_, PlatformThread::CurrentId());
+  DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   DVLOG(1) << __FUNCTION__ << me() << "headers: \n" << response_headers;
 
   if (!delegate_) {
     DLOG(WARNING) << "Invalid delegate";
     return S_OK;
   }
 
   std::string raw_headers = WideToUTF8(response_headers);
 
   delegate_->AddPrivacyDataForUrl(url(), "", 0);
@@ skipping 194 matching lines @@
     }
   }
 
   DLOG_IF(ERROR, FAILED(hr)) << me() <<
       base::StringPrintf(L"StartAsyncDownload failed: 0x%08X", hr);
 
   return hr;
 }
 
 void UrlmonUrlRequest::NotifyDelegateAndDie() {
-  DCHECK_EQ(thread_, PlatformThread::CurrentId());
+  DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   DVLOG(1) << __FUNCTION__ << me();
 
   PluginUrlRequestDelegate* delegate = delegate_;
   delegate_ = NULL;
   ReleaseBindings();
   TerminateTransaction();
   if (delegate) {
     URLRequestStatus result = status_.get_result();
     delegate->OnResponseEnd(id(), result);
   } else {
@@ skipping 394 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);
   }
 }