[SyncFS] Add TaskLogger and wire up it.

chrome/browser/sync_file_system/drive_backend/sync_engine.cc

 // Copyright 2013 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/sync_file_system/drive_backend/sync_engine.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
@@ skipping 116 matching lines @@
                        const SyncStatusCallback& callback,
                        SyncStatusCode status) {
   base::TimeDelta delta(base::TimeTicks::Now() - start_time);
   HISTOGRAM_TIMES("SyncFileSystem.RegisterOriginTime", delta);
   callback.Run(status);
 }
 
 }  // namespace
 
 scoped_ptr<SyncEngine> SyncEngine::CreateForBrowserContext(
-    content::BrowserContext* context) {
+    content::BrowserContext* context,
+    TaskLogger* task_logger) {
   scoped_refptr<base::SequencedWorkerPool> worker_pool(
       content::BrowserThread::GetBlockingPool());
   scoped_refptr<base::SequencedTaskRunner> drive_task_runner(
       worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
           worker_pool->GetSequenceToken(),
           base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
 
   Profile* profile = Profile::FromBrowserContext(context);
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
@@ skipping 29 matching lines @@
       worker_task_runner = base::MessageLoopProxy::current();
 
   scoped_ptr<drive_backend::SyncEngine> sync_engine(
       new SyncEngine(drive_service.Pass(),
                      drive_uploader.Pass(),
                      worker_task_runner,
                      notification_manager,
                      extension_service,
                      signin_manager));
   sync_engine->Initialize(GetSyncFileSystemDir(context->GetPath()),
+                          task_logger,
                           file_task_runner.get(),
                           NULL);
 
   return sync_engine.Pass();
 }
 
 void SyncEngine::AppendDependsOnFactories(
     std::set<BrowserContextKeyedServiceFactory*>* factories) {
   DCHECK(factories);
   factories->insert(drive::DriveNotificationManagerFactory::GetInstance());
   factories->insert(SigninManagerFactory::GetInstance());
   factories->insert(
       extensions::ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
 }
 
 SyncEngine::~SyncEngine() {
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
   GetDriveService()->RemoveObserver(this);
   if (notification_manager_)
     notification_manager_->RemoveObserver(this);
 
   // TODO(tzik): Destroy |sync_worker_| and |worker_observer_| on the worker.
 }
 
 void SyncEngine::Initialize(const base::FilePath& base_dir,
+                            TaskLogger* task_logger,
                             base::SequencedTaskRunner* file_task_runner,
                             leveldb::Env* env_override) {
   // DriveServiceWrapper and DriveServiceOnWorker relay communications
   // between DriveService and syncers in SyncWorker.
-  scoped_ptr<drive::DriveServiceInterface>
-      drive_service_on_worker(
-          new DriveServiceOnWorker(drive_service_wrapper_->AsWeakPtr(),
-                                   base::MessageLoopProxy::current(),
-                                   worker_task_runner_));
-  scoped_ptr<drive::DriveUploaderInterface>
-      drive_uploader_on_worker(
-          new DriveUploaderOnWorker(drive_uploader_wrapper_->AsWeakPtr(),
-                                    base::MessageLoopProxy::current(),
-                                    worker_task_runner_));
-  scoped_ptr<SyncEngineContext>
-      sync_engine_context(
-          new SyncEngineContext(drive_service_on_worker.Pass(),
-                                drive_uploader_on_worker.Pass(),
+  scoped_ptr<drive::DriveServiceInterface> drive_service_on_worker(
+      new DriveServiceOnWorker(drive_service_wrapper_->AsWeakPtr(),
+                               base::MessageLoopProxy::current(),
+                               worker_task_runner_));
+  scoped_ptr<drive::DriveUploaderInterface> drive_uploader_on_worker(
+      new DriveUploaderOnWorker(drive_uploader_wrapper_->AsWeakPtr(),
                                 base::MessageLoopProxy::current(),
-                                worker_task_runner_,
-                                file_task_runner));
+                                worker_task_runner_));
+  scoped_ptr<SyncEngineContext> sync_engine_context(
+      new SyncEngineContext(drive_service_on_worker.Pass(),
+                            drive_uploader_on_worker.Pass(),
+                            task_logger,
+                            base::MessageLoopProxy::current(),
+                            worker_task_runner_,
+                            file_task_runner));
 
   worker_observer_.reset(
       new WorkerObserver(base::MessageLoopProxy::current(),
                          weak_ptr_factory_.GetWeakPtr()));
 
   base::WeakPtr<ExtensionServiceInterface> extension_service_weak_ptr;
   if (extension_service_)
     extension_service_weak_ptr = extension_service_->AsWeakPtr();
 
   // TODO(peria): Use PostTask on |worker_task_runner_| to call this function.
@@ skipping 297 matching lines @@
         tracker.tracker_kind() == TRACKER_KIND_APP_ROOT;
     if (is_app_enabled && !is_app_root_tracker_enabled)
       EnableOrigin(origin, base::Bind(&EmptyStatusCallback));
     else if (!is_app_enabled && is_app_root_tracker_enabled)
       DisableOrigin(origin, base::Bind(&EmptyStatusCallback));
   }
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system