Move CancelableTaskTracker to //base/task/CancelableTaskTracker.

chrome/browser/chromeos/system/syslogs_provider.cc

 // Copyright (c) 2012 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/browser/chromeos/system/syslogs_provider.h"
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 164 matching lines @@
   }
 
   return logs;
 }
 
 }  // namespace
 
 class SyslogsProviderImpl : public SyslogsProvider {
  public:
   // SyslogsProvider implementation:
-  virtual CancelableTaskTracker::TaskId RequestSyslogs(
+  virtual base::CancelableTaskTracker::TaskId RequestSyslogs(
       bool compress_logs,
       SyslogsContext context,
       const ReadCompleteCallback& callback,
-      CancelableTaskTracker* tracker) OVERRIDE;
+      base::CancelableTaskTracker* tracker) OVERRIDE;
 
   static SyslogsProviderImpl* GetInstance();
 
  private:
   friend struct DefaultSingletonTraits<SyslogsProviderImpl>;
 
   // Reads system logs, compresses content if requested.
   // Called from blocking pool thread.
   void ReadSyslogs(
-      const CancelableTaskTracker::IsCanceledCallback& is_canceled,
+      const base::CancelableTaskTracker::IsCanceledCallback& is_canceled,
       bool compress_logs,
       SyslogsContext context,
       const ReadCompleteCallback& callback);
 
   // Loads compressed logs and writes into |zip_content|.
   void LoadCompressedLogs(const base::FilePath& zip_file,
                           std::string* zip_content);
 
   SyslogsProviderImpl();
 
   // Gets syslogs context string from the enum value.
   const char* GetSyslogsContextString(SyslogsContext context);
 
   // If not canceled, run callback on originating thread (the thread on which
   // ReadSyslogs was run).
   static void RunCallbackIfNotCanceled(
-      const CancelableTaskTracker::IsCanceledCallback& is_canceled,
+      const base::CancelableTaskTracker::IsCanceledCallback& is_canceled,
       base::TaskRunner* origin_runner,
       const ReadCompleteCallback& callback,
       LogDictionaryType* logs,
       std::string* zip_content);
 
   DISALLOW_COPY_AND_ASSIGN(SyslogsProviderImpl);
 };
 
 SyslogsProviderImpl::SyslogsProviderImpl() {
 }
 
-CancelableTaskTracker::TaskId SyslogsProviderImpl::RequestSyslogs(
+base::CancelableTaskTracker::TaskId SyslogsProviderImpl::RequestSyslogs(
     bool compress_logs,
     SyslogsContext context,
     const ReadCompleteCallback& callback,
-    CancelableTaskTracker* tracker) {
-  CancelableTaskTracker::IsCanceledCallback is_canceled;
-  CancelableTaskTracker::TaskId id = tracker->NewTrackedTaskId(&is_canceled);
+    base::CancelableTaskTracker* tracker) {
+  base::CancelableTaskTracker::IsCanceledCallback is_canceled;
+  base::CancelableTaskTracker::TaskId id =
+      tracker->NewTrackedTaskId(&is_canceled);
 
   ReadCompleteCallback callback_runner =
       base::Bind(&SyslogsProviderImpl::RunCallbackIfNotCanceled,
                  is_canceled, base::MessageLoopProxy::current(), callback);
 
   // Schedule a task which will run the callback later when complete.
   BrowserThread::PostBlockingPoolTask(
       FROM_HERE,
       base::Bind(&SyslogsProviderImpl::ReadSyslogs, base::Unretained(this),
                  is_canceled, compress_logs, context, callback_runner));
@@ skipping 43 matching lines @@
 
 void SyslogsMemoryHandler::OnDetailsAvailable() {
     (*logs_)["mem_usage"] = ToLogString();
     callback_.Run(logs_, zip_content_);
   }
 
 SyslogsMemoryHandler::~SyslogsMemoryHandler() {}
 
 // Called from blocking pool thread.
 void SyslogsProviderImpl::ReadSyslogs(
-    const CancelableTaskTracker::IsCanceledCallback& is_canceled,
+    const base::CancelableTaskTracker::IsCanceledCallback& is_canceled,
     bool compress_logs,
     SyslogsContext context,
     const ReadCompleteCallback& callback) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   if (is_canceled.Run())
     return;
 
   // Create temp file.
   base::FilePath zip_file;
@@ skipping 57 matching lines @@
     case(SYSLOGS_DEFAULT):
       return kContextSysInfo;
     default:
       NOTREACHED();
       return "";
   }
 }
 
 // static
 void SyslogsProviderImpl::RunCallbackIfNotCanceled(
-    const CancelableTaskTracker::IsCanceledCallback& is_canceled,
+    const base::CancelableTaskTracker::IsCanceledCallback& is_canceled,
     base::TaskRunner* origin_runner,
     const ReadCompleteCallback& callback,
     LogDictionaryType* logs,
     std::string* zip_content) {
   DCHECK(!is_canceled.is_null() && !callback.is_null());
 
   if (is_canceled.Run()) {
     delete logs;
     delete zip_content;
     return;
@@ skipping 11 matching lines @@
   return Singleton<SyslogsProviderImpl,
                    DefaultSingletonTraits<SyslogsProviderImpl> >::get();
 }
 
 SyslogsProvider* SyslogsProvider::GetInstance() {
   return SyslogsProviderImpl::GetInstance();
 }
 
 }  // namespace system
 }  // namespace chromeos