FileAPI/sync file system cleanups for scoped_refptr operator T* cleanup.

chrome/browser/sync_file_system/drive_backend/metadata_database.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/metadata_database.h"
 
 #include <algorithm>
 #include <stack>
 
 #include "base/bind.h"
@@ skipping 506 matching lines @@
   }
 }
 
 }  // namespace
 
 struct MetadataDatabase::CreateParam {
   scoped_refptr<base::SequencedTaskRunner> worker_task_runner;
   base::FilePath database_path;
   leveldb::Env* env_override;
 
-  CreateParam(base::SequencedTaskRunner* worker_task_runner,
-              const base::FilePath& database_path,
-              leveldb::Env* env_override)
+  CreateParam(
+      const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
+      const base::FilePath& database_path,
+      leveldb::Env* env_override)
       : worker_task_runner(worker_task_runner),
         database_path(database_path),
-        env_override(env_override) {
-  }
+        env_override(env_override) {}
 };
 
 // static
-void MetadataDatabase::Create(base::SequencedTaskRunner* worker_task_runner,
-                              const base::FilePath& database_path,
-                              leveldb::Env* env_override,
-                              const CreateCallback& callback) {
+void MetadataDatabase::Create(
+    const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
+    const base::FilePath& database_path,
+    leveldb::Env* env_override,
+    const CreateCallback& callback) {
   worker_task_runner->PostTask(FROM_HERE, base::Bind(
       &MetadataDatabase::CreateOnWorkerTaskRunner,
       base::Passed(make_scoped_ptr(new CreateParam(
           worker_task_runner,
           database_path,
           env_override))),
       callback));
 }
 
 // static
@@ skipping 844 matching lines @@
         !CanClearDirty(*tracker))
       continue;
     tracker->set_dirty(false);
     index_->StoreFileTracker(tracker.Pass());
   }
 
   WriteToDatabase(callback);
 }
 
 MetadataDatabase::MetadataDatabase(
-    base::SequencedTaskRunner* worker_task_runner,
+    const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
     const base::FilePath& database_path,
     leveldb::Env* env_override)
     : worker_task_runner_(worker_task_runner),
       database_path_(database_path),
       env_override_(env_override),
       largest_known_change_id_(0),
       weak_ptr_factory_(this) {
-  DCHECK(worker_task_runner);
+  DCHECK(worker_task_runner.get());
 }
 
 // static
 void MetadataDatabase::CreateOnWorkerTaskRunner(
     scoped_ptr<CreateParam> create_param,
     const CreateCallback& callback) {
   DCHECK(create_param->worker_task_runner->RunsTasksOnCurrentThread());
 
   scoped_ptr<MetadataDatabase> metadata_database(
-      new MetadataDatabase(create_param->worker_task_runner.get(),
+      new MetadataDatabase(create_param->worker_task_runner,
                            create_param->database_path,
                            create_param->env_override));
   SyncStatusCode status = metadata_database->Initialize();
   if (status != SYNC_STATUS_OK)
     metadata_database.reset();
 
   metadata_database->DetachFromSequence();
   create_param->worker_task_runner->PostTask(
       FROM_HERE,
       base::Bind(
@@ skipping 519 matching lines @@
       return false;
 
   if (!parents.empty())
     return false;
 
   return true;
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system