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

chrome_frame/chrome_frame_automation.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/chrome_frame_automation.h"
 
 #include "app/app_switches.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 238 matching lines @@
   DCHECK(!snapshots_);
   snapshots_ = snapshots;
   uma_send_interval_ = send_interval;
   thread_->message_loop()->PostDelayedTask(FROM_HERE,
       NewRunnableMethod(this, &AutomationProxyCacheEntry::SendUMAData),
       send_interval);
 }
 
 void AutomationProxyCacheEntry::CreateProxy(ChromeFrameLaunchParams* params,
                                             LaunchDelegate* delegate) {
-  DCHECK(IsSameThread(PlatformThread::CurrentId()));
+  DCHECK(IsSameThread(base::PlatformThread::CurrentId()));
   DCHECK(delegate);
   DCHECK(params);
   DCHECK(proxy_.get() == NULL);
 
   // We *must* create automationproxy in a thread that has message loop,
   // since SyncChannel::Context construction registers event to be watched
   // through ObjectWatcher which subscribes for the current thread message loop
   // destruction notification.
 
   // At same time we must destroy/stop the thread from another thread.
@@ skipping 101 matching lines @@
   // Finally set the proxy.
   proxy_.reset(proxy);
   launch_delegates_.push_back(delegate);
 
   delegate->LaunchComplete(proxy_.get(), launch_result_);
 }
 
 void AutomationProxyCacheEntry::RemoveDelegate(LaunchDelegate* delegate,
                                                base::WaitableEvent* done,
                                                bool* was_last_delegate) {
-  DCHECK(IsSameThread(PlatformThread::CurrentId()));
+  DCHECK(IsSameThread(base::PlatformThread::CurrentId()));
   DCHECK(delegate);
   DCHECK(done);
   DCHECK(was_last_delegate);
 
   *was_last_delegate = false;
 
   LaunchDelegates::iterator it = std::find(launch_delegates_.begin(),
       launch_delegates_.end(), delegate);
   if (it == launch_delegates_.end()) {
     NOTREACHED();
@@ skipping 13 matching lines @@
     // Be careful to remove from the list after running pending
     // tasks.  Otherwise the delegate being removed might miss out
     // on pending notifications such as LaunchComplete.
     launch_delegates_.erase(it);
   }
 
   done->Signal();
 }
 
 void AutomationProxyCacheEntry::AddDelegate(LaunchDelegate* delegate) {
-  DCHECK(IsSameThread(PlatformThread::CurrentId()));
+  DCHECK(IsSameThread(base::PlatformThread::CurrentId()));
   DCHECK(std::find(launch_delegates_.begin(),
                    launch_delegates_.end(),
                    delegate) == launch_delegates_.end())
       << "Same delegate being added twice";
   DCHECK(launch_result_ != AUTOMATION_LAUNCH_RESULT_INVALID);
 
   launch_delegates_.push_back(delegate);
   delegate->LaunchComplete(proxy_.get(), launch_result_);
 }
 
 void AutomationProxyCacheEntry::OnChannelError() {
-  DCHECK(IsSameThread(PlatformThread::CurrentId()));
+  DCHECK(IsSameThread(base::PlatformThread::CurrentId()));
   launch_result_ = AUTOMATION_SERVER_CRASHED;
   LaunchDelegates::const_iterator it = launch_delegates_.begin();
   for (; it != launch_delegates_.end(); ++it) {
     (*it)->AutomationServerDied();
   }
 }
 
 void AutomationProxyCacheEntry::SendUMAData() {
-  DCHECK(IsSameThread(PlatformThread::CurrentId()));
+  DCHECK(IsSameThread(base::PlatformThread::CurrentId()));
   DCHECK(snapshots_);
   // IE uses the chrome frame provided UMA data uploading scheme. NPAPI
   // continues to use Chrome to upload UMA data.
   if (CrashMetricsReporter::GetInstance()->active()) {
     return;
   }
 
   if (!proxy_.get()) {
     DLOG(WARNING) << __FUNCTION__ << " NULL proxy, can't send UMA data";
   } else {
@@ skipping 55 matching lines @@
                                   uma_send_interval_);
     }
   } else if (delegate) {
     // Notify the new delegate of the launch status from the worker thread
     // and add it to the list of delegates.
     entry->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(entry.get(),
         &AutomationProxyCacheEntry::AddDelegate, delegate));
   }
 
   DCHECK(automation_server_id != NULL);
-  DCHECK(!entry->IsSameThread(PlatformThread::CurrentId()));
+  DCHECK(!entry->IsSameThread(base::PlatformThread::CurrentId()));
 
   *automation_server_id = entry;
 }
 
 bool ProxyFactory::ReleaseAutomationServer(void* server_id,
                                            LaunchDelegate* delegate) {
   if (!server_id) {
     NOTREACHED();
     return false;
   }
 
   AutomationProxyCacheEntry* entry =
       reinterpret_cast<AutomationProxyCacheEntry*>(server_id);
 
 #ifndef NDEBUG
   lock_.Acquire();
   Vector::ContainerType::iterator it = std::find(proxies_.container().begin(),
                                                  proxies_.container().end(),
                                                  entry);
   DCHECK(it != proxies_.container().end());
-  DCHECK(!entry->IsSameThread(PlatformThread::CurrentId()));
+  DCHECK(!entry->IsSameThread(base::PlatformThread::CurrentId()));
 
   lock_.Release();
 #endif
 
   // AddRef the entry object as we might need to take it out of the proxy
   // stack and then uninitialize the entry.
   entry->AddRef();
 
   bool last_delegate = false;
   if (delegate) {
@@ skipping 62 matching lines @@
 #ifndef NDEBUG
   if (chrome_launch_params_ && chrome_launch_params_ != chrome_launch_params) {
     DCHECK_EQ(chrome_launch_params_->url(), chrome_launch_params->url());
     DCHECK_EQ(chrome_launch_params_->referrer(),
               chrome_launch_params->referrer());
   }
 #endif
 
   chrome_launch_params_ = chrome_launch_params;
 
-  ui_thread_id_ = PlatformThread::CurrentId();
+  ui_thread_id_ = base::PlatformThread::CurrentId();
 #ifndef NDEBUG
   // In debug mode give more time to work with a debugger.
   if (IsDebuggerPresent()) {
     // Don't use INFINITE (which is -1) or even MAXINT since we will convert
     // from milliseconds to microseconds when stored in a base::TimeDelta,
     // thus * 1000. An hour should be enough.
     chrome_launch_params_->set_launch_timeout(60 * 60 * 1000);
   } else {
     DCHECK_LT(chrome_launch_params_->launch_timeout(),
               MAXINT / 2000);
@@ skipping 234 matching lines @@
   IPC::SyncMessage* msg = new AutomationMsg_InstallExtension(crx_path, NULL);
 
   // The context will delete itself after it is called.
   automation_server_->SendAsAsync(msg, ctx, this);
 }
 
 void ChromeFrameAutomationClient::InstallExtensionComplete(
     const FilePath& crx_path,
     void* user_data,
     AutomationMsg_ExtensionResponseValues res) {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
+  DCHECK_EQ(base::PlatformThread::CurrentId(), ui_thread_id_);
 
   if (chrome_frame_delegate_) {
     chrome_frame_delegate_->OnExtensionInstalled(crx_path, user_data, res);
   }
 }
 
 void ChromeFrameAutomationClient::GetEnabledExtensions(void* user_data) {
     if (automation_server_ == NULL) {
       GetEnabledExtensionsComplete(user_data, &std::vector<FilePath>());
       return;
     }
 
     GetEnabledExtensionsContext* ctx = new GetEnabledExtensionsContext(
         this, user_data);
 
     IPC::SyncMessage* msg = new AutomationMsg_GetEnabledExtensions(
         ctx->extension_directories());
 
     // The context will delete itself after it is called.
     automation_server_->SendAsAsync(msg, ctx, this);
 }
 
 void ChromeFrameAutomationClient::GetEnabledExtensionsComplete(
     void* user_data,
     std::vector<FilePath>* extension_directories) {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
+  DCHECK_EQ(base::PlatformThread::CurrentId(), ui_thread_id_);
 
   if (chrome_frame_delegate_) {
     chrome_frame_delegate_->OnGetEnabledExtensionsComplete(
         user_data, *extension_directories);
   }
 
   delete extension_directories;
 }
 
 int ChromeFrameAutomationClient::GetSessionId() const {
@@ skipping 149 matching lines @@
   PostTask(FROM_HERE, NewRunnableMethod(this,
       &ChromeFrameAutomationClient::InitializeComplete,
       AUTOMATION_SERVER_CRASHED));
   // Then uninitialize.
   PostTask(FROM_HERE, NewRunnableMethod(this,
       &ChromeFrameAutomationClient::Uninitialize));
 }
 
 void ChromeFrameAutomationClient::InitializeComplete(
     AutomationLaunchResult result) {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
+  DCHECK_EQ(base::PlatformThread::CurrentId(), ui_thread_id_);
   if (result != AUTOMATION_SUCCESS) {
     DLOG(WARNING) << "InitializeComplete: failure " << result;
     ReleaseAutomationServer();
   } else {
     init_state_ = INITIALIZED;
 
     // If the host already have a window, ask Chrome to re-parent.
     if (parent_window_)
       SetParentWindow(parent_window_);
 
@@ skipping 112 matching lines @@
   // Early check to avoid needless marshaling
   if (chrome_frame_delegate_ == NULL)
     return;
 
   PostTask(FROM_HERE, NewRunnableMethod(this,
       &ChromeFrameAutomationClient::OnChannelErrorUIThread));
 }
 
 void ChromeFrameAutomationClient::OnMessageReceivedUIThread(
     const IPC::Message& msg) {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
+  DCHECK_EQ(base::PlatformThread::CurrentId(), ui_thread_id_);
   // Forward to the delegate.
   if (chrome_frame_delegate_)
     chrome_frame_delegate_->OnMessageReceived(msg);
 }
 
 void ChromeFrameAutomationClient::OnChannelErrorUIThread() {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
+  DCHECK_EQ(base::PlatformThread::CurrentId(), ui_thread_id_);
 
   // Report a metric that something went wrong unexpectedly.
   CrashMetricsReporter::GetInstance()->IncrementMetric(
       CrashMetricsReporter::CHANNEL_ERROR_COUNT);
 
   // Forward to the delegate.
   if (chrome_frame_delegate_)
     chrome_frame_delegate_->OnChannelError();
 }
 
 void ChromeFrameAutomationClient::ReportNavigationError(
     AutomationMsg_NavigationResponseValues error_code,
     const std::string& url) {
   if (!chrome_frame_delegate_)
     return;
 
-  if (ui_thread_id_ == PlatformThread::CurrentId()) {
+  if (ui_thread_id_ == base::PlatformThread::CurrentId()) {
     chrome_frame_delegate_->OnLoadFailed(error_code, url);
   } else {
     PostTask(FROM_HERE, NewRunnableMethod(this,
         &ChromeFrameAutomationClient::ReportNavigationError,
         error_code, url));
   }
 }
 
 void ChromeFrameAutomationClient::Resize(int width, int height,
                                          int flags) {
@@ skipping 222 matching lines @@
     const URLRequestStatus& status) {
   automation_server_->Send(new AutomationMsg_RequestEnd(
       tab_->handle(), request_id, status));
 }
 
 void ChromeFrameAutomationClient::OnCookiesRetrieved(bool success,
     const GURL& url, const std::string& cookie_string, int cookie_id) {
   automation_server_->Send(new AutomationMsg_GetCookiesHostResponse(
       tab_->handle(), success, url, cookie_string, cookie_id));
 }