Update webkit/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

Linux fixes

BUG=110610
TBR=darin

Review URL: https://chromiumcodereview.appspot.com/16155009

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@203636 0039d316-1c4b-4281-b951-d872f2087c98

29 files changed, 286 insertions, 226 deletions

diff --git a/webkit/browser/fileapi/copy_or_move_file_validator_unittest.cc b/webkit/browser/fileapi/copy_or_move_file_validator_unittest.cc
index 92b9d04..b971fd5 100644
--- a/webkit/browser/fileapi/copy_or_move_file_validator_unittest.cc
+++ b/webkit/browser/fileapi/copy_or_move_file_validator_unittest.cc
@@ -98,8 +98,8 @@ class CopyOrMoveFileValidatorTestHelper {
     ASSERT_FALSE(FileExists(copy_dest_, 10));
 
     EXPECT_EQ(expected,
-              AsyncFileTestHelper::Copy(file_system_context_, copy_src_,
-                                        copy_dest_));
+              AsyncFileTestHelper::Copy(
+                  file_system_context_.get(), copy_src_, copy_dest_));
 
     EXPECT_TRUE(FileExists(copy_src_, 10));
     if (expected == base::PLATFORM_FILE_OK)
@@ -113,8 +113,8 @@ class CopyOrMoveFileValidatorTestHelper {
     ASSERT_FALSE(FileExists(move_dest_, 10));
 
     EXPECT_EQ(expected,
-              AsyncFileTestHelper::Move(file_system_context_, move_src_,
-                                        move_dest_));
+              AsyncFileTestHelper::Move(
+                  file_system_context_.get(), move_src_, move_dest_));
 
     if (expected == base::PLATFORM_FILE_OK) {
       EXPECT_FALSE(FileExists(move_src_, 10));
@@ -140,19 +140,21 @@ class CopyOrMoveFileValidatorTestHelper {
 
   base::PlatformFileError CreateFile(const FileSystemURL& url, size_t size) {
     base::PlatformFileError result =
-        AsyncFileTestHelper::CreateFile(file_system_context_, url);
+        AsyncFileTestHelper::CreateFile(file_system_context_.get(), url);
     if (result != base::PLATFORM_FILE_OK)
       return result;
-    return AsyncFileTestHelper::TruncateFile(file_system_context_, url, size);
+    return AsyncFileTestHelper::TruncateFile(
+        file_system_context_.get(), url, size);
   }
 
   base::PlatformFileError CreateDirectory(const FileSystemURL& url) {
-    return AsyncFileTestHelper::CreateDirectory(file_system_context_, url);
+    return AsyncFileTestHelper::CreateDirectory(file_system_context_.get(),
+                                                url);
   }
 
   bool FileExists(const FileSystemURL& url, int64 expected_size) {
     return AsyncFileTestHelper::FileExists(
-        file_system_context_, url, expected_size);
+        file_system_context_.get(), url, expected_size);
   }
 
   base::ScopedTempDir base_;
diff --git a/webkit/browser/fileapi/file_system_context_unittest.cc b/webkit/browser/fileapi/file_system_context_unittest.cc
index c699fd2..d6ac71a 100644
--- a/webkit/browser/fileapi/file_system_context_unittest.cc
+++ b/webkit/browser/fileapi/file_system_context_unittest.cc
@@ -49,25 +49,24 @@ class FileSystemContextTest : public testing::Test {
 
     storage_policy_ = new quota::MockSpecialStoragePolicy();
 
-    mock_quota_manager_ = new quota::MockQuotaManager(
-        false /* is_incognito */,
-        data_dir_.path(),
-        base::MessageLoopProxy::current(),
-        base::MessageLoopProxy::current(),
-        storage_policy_);
+    mock_quota_manager_ =
+        new quota::MockQuotaManager(false /* is_incognito */,
+                                    data_dir_.path(),
+                                    base::MessageLoopProxy::current(),
+                                    base::MessageLoopProxy::current(),
+                                    storage_policy_.get());
   }
 
  protected:
   FileSystemContext* CreateFileSystemContextForTest(
       ExternalMountPoints* external_mount_points) {
-    return new FileSystemContext(
-        FileSystemTaskRunners::CreateMockTaskRunners(),
-        external_mount_points,
-        storage_policy_,
-        mock_quota_manager_->proxy(),
-        ScopedVector<FileSystemMountPointProvider>(),
-        data_dir_.path(),
-        CreateAllowFileAccessOptions());
+    return new FileSystemContext(FileSystemTaskRunners::CreateMockTaskRunners(),
+                                 external_mount_points,
+                                 storage_policy_.get(),
+                                 mock_quota_manager_->proxy(),
+                                 ScopedVector<FileSystemMountPointProvider>(),
+                                 data_dir_.path(),
+                                 CreateAllowFileAccessOptions());
   }
 
   // Verifies a *valid* filesystem url has expected values.
@@ -186,7 +185,7 @@ TEST_F(FileSystemContextTest, CrackFileSystemURL) {
   scoped_refptr<ExternalMountPoints> external_mount_points(
       ExternalMountPoints::CreateRefCounted());
   scoped_refptr<FileSystemContext> file_system_context(
-      CreateFileSystemContextForTest(external_mount_points));
+      CreateFileSystemContextForTest(external_mount_points.get()));
 
   // Register an isolated mount point.
   std::string isolated_file_system_name = "root";
diff --git a/webkit/browser/fileapi/file_system_dir_url_request_job_unittest.cc b/webkit/browser/fileapi/file_system_dir_url_request_job_unittest.cc
index f8cc7de..153752e 100644
--- a/webkit/browser/fileapi/file_system_dir_url_request_job_unittest.cc
+++ b/webkit/browser/fileapi/file_system_dir_url_request_job_unittest.cc
@@ -106,8 +106,8 @@ class FileSystemDirURLRequestJobTest : public testing::Test {
   }
 
   FileSystemOperationContext* NewOperationContext() {
-    FileSystemOperationContext* context(new FileSystemOperationContext(
-        file_system_context_));
+    FileSystemOperationContext* context(
+        new FileSystemOperationContext(file_system_context_.get()));
     context->set_allowed_bytes_growth(1024);
     return context;
   }
diff --git a/webkit/browser/fileapi/file_system_file_stream_reader_unittest.cc b/webkit/browser/fileapi/file_system_file_stream_reader_unittest.cc
index 68a7132..31f91ae 100644
--- a/webkit/browser/fileapi/file_system_file_stream_reader_unittest.cc
+++ b/webkit/browser/fileapi/file_system_file_stream_reader_unittest.cc
@@ -43,7 +43,7 @@ void ReadFromReader(FileSystemFileStreamReader* reader,
   while (total_bytes_read < size) {
     scoped_refptr<net::IOBufferWithSize> buf(
         new net::IOBufferWithSize(size - total_bytes_read));
-    int rv = reader->Read(buf, buf->size(), callback.callback());
+    int rv = reader->Read(buf.get(), buf->size(), callback.callback());
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
@@ -89,7 +89,7 @@ class FileSystemFileStreamReaderTest : public testing::Test {
       const std::string& file_name,
       int64 initial_offset,
       const base::Time& expected_modification_time) {
-    return new FileSystemFileStreamReader(file_system_context_,
+    return new FileSystemFileStreamReader(file_system_context_.get(),
                                           GetFileSystemURL(file_name),
                                           initial_offset,
                                           expected_modification_time);
@@ -107,7 +107,7 @@ class FileSystemFileStreamReaderTest : public testing::Test {
         sandbox_provider()->GetFileUtil(kFileSystemTypeTemporary);
     FileSystemURL url = GetFileSystemURL(file_name);
 
-    FileSystemOperationContext context(file_system_context_);
+    FileSystemOperationContext context(file_system_context_.get());
     context.set_allowed_bytes_growth(1024);
 
     base::PlatformFile handle = base::kInvalidPlatformFileValue;
@@ -271,7 +271,7 @@ TEST_F(FileSystemFileStreamReaderTest, DeleteWithUnfinishedRead) {
   net::TestCompletionCallback callback;
   scoped_refptr<net::IOBufferWithSize> buf(
       new net::IOBufferWithSize(kTestDataSize));
-  int rv = reader->Read(buf, buf->size(), base::Bind(&NeverCalled));
+  int rv = reader->Read(buf.get(), buf->size(), base::Bind(&NeverCalled));
   ASSERT_TRUE(rv == net::ERR_IO_PENDING || rv >= 0);
 
   // Delete immediately.
diff --git a/webkit/browser/fileapi/file_system_quota_client_unittest.cc b/webkit/browser/fileapi/file_system_quota_client_unittest.cc
index ade671a..5e69a1a 100644
--- a/webkit/browser/fileapi/file_system_quota_client_unittest.cc
+++ b/webkit/browser/fileapi/file_system_quota_client_unittest.cc
@@ -59,8 +59,7 @@ class FileSystemQuotaClientTest : public testing::Test {
 
  protected:
   FileSystemQuotaClient* NewQuotaClient(bool is_incognito) {
-    return new FileSystemQuotaClient(
-        file_system_context_, is_incognito);
+    return new FileSystemQuotaClient(file_system_context_.get(), is_incognito);
   }
 
   void GetOriginUsageAsync(FileSystemQuotaClient* quota_client,
@@ -115,7 +114,7 @@ class FileSystemQuotaClientTest : public testing::Test {
   FileSystemOperationContext* CreateFileSystemOperationContext(
       FileSystemType type) {
     FileSystemOperationContext* context =
-        new FileSystemOperationContext(file_system_context_);
+        new FileSystemOperationContext(file_system_context_.get());
     context->set_allowed_bytes_growth(100000000);
     context->set_update_observers(
         *file_system_context_->GetUpdateObservers(type));
diff --git a/webkit/browser/fileapi/file_system_url_request_job_unittest.cc b/webkit/browser/fileapi/file_system_url_request_job_unittest.cc
index ce59f3c..0b1db55 100644
--- a/webkit/browser/fileapi/file_system_url_request_job_unittest.cc
+++ b/webkit/browser/fileapi/file_system_url_request_job_unittest.cc
@@ -76,7 +76,7 @@ class FileSystemURLRequestJobTest : public testing::Test {
   virtual void TearDown() OVERRIDE {
     net::URLRequest::Deprecated::RegisterProtocolFactory("filesystem", NULL);
     ClearUnusedJob();
-    if (pending_job_) {
+    if (pending_job_.get()) {
       pending_job_->Kill();
       pending_job_ = NULL;
     }
@@ -130,7 +130,7 @@ class FileSystemURLRequestJobTest : public testing::Test {
         kFileSystemTypeTemporary,
         base::FilePath().AppendASCII(dir_name));
 
-    FileSystemOperationContext context(file_system_context_);
+    FileSystemOperationContext context(file_system_context_.get());
     context.set_allowed_bytes_growth(1024);
 
     ASSERT_EQ(base::PLATFORM_FILE_OK, file_util->CreateDirectory(
@@ -149,7 +149,7 @@ class FileSystemURLRequestJobTest : public testing::Test {
         kFileSystemTypeTemporary,
         base::FilePath().AppendASCII(file_name));
 
-    FileSystemOperationContext context(file_system_context_);
+    FileSystemOperationContext context(file_system_context_.get());
     context.set_allowed_bytes_growth(1024);
 
     base::PlatformFile handle = base::kInvalidPlatformFileValue;
diff --git a/webkit/browser/fileapi/file_system_usage_cache.cc b/webkit/browser/fileapi/file_system_usage_cache.cc
index d6eb8f3..59dfbbd 100644
--- a/webkit/browser/fileapi/file_system_usage_cache.cc
+++ b/webkit/browser/fileapi/file_system_usage_cache.cc
@@ -299,7 +299,7 @@ void FileSystemUsageCache::ScheduleCloseTimer() {
 }
 
 bool FileSystemUsageCache::CalledOnValidThread() {
-  return !task_runner_ || task_runner_->RunsTasksOnCurrentThread();
+  return !task_runner_.get() || task_runner_->RunsTasksOnCurrentThread();
 }
 
 bool FileSystemUsageCache::HasCacheFileHandle(const base::FilePath& file_path) {
diff --git a/webkit/browser/fileapi/file_writer_delegate.cc b/webkit/browser/fileapi/file_writer_delegate.cc
index f3a2d94..3c7b781 100644
--- a/webkit/browser/fileapi/file_writer_delegate.cc
+++ b/webkit/browser/fileapi/file_writer_delegate.cc
@@ -143,7 +143,7 @@ void FileWriterDelegate::OnDataReceived(int bytes_read) {
     // This could easily be optimized to rotate between a pool of buffers, so
     // that we could read and write at the same time.  It's not yet clear that
     // it's necessary.
-    cursor_ = new net::DrainableIOBuffer(io_buffer_, bytes_read_);
+    cursor_ = new net::DrainableIOBuffer(io_buffer_.get(), bytes_read_);
     Write();
   }
 }
@@ -152,7 +152,7 @@ void FileWriterDelegate::Write() {
   writing_started_ = true;
   int64 bytes_to_write = bytes_read_ - bytes_written_;
   int write_response =
-      file_stream_writer_->Write(cursor_,
+      file_stream_writer_->Write(cursor_.get(),
                                  static_cast<int>(bytes_to_write),
                                  base::Bind(&FileWriterDelegate::OnDataWritten,
                                             weak_factory_.GetWeakPtr()));
diff --git a/webkit/browser/fileapi/file_writer_delegate_unittest.cc b/webkit/browser/fileapi/file_writer_delegate_unittest.cc
index c094ea1..36eb72b 100644
--- a/webkit/browser/fileapi/file_writer_delegate_unittest.cc
+++ b/webkit/browser/fileapi/file_writer_delegate_unittest.cc
@@ -86,10 +86,9 @@ class FileWriterDelegateTest : public PlatformTest {
   }
 
   int64 usage() {
-    return file_system_context_->GetQuotaUtil(kFileSystemType)->
-        GetOriginUsageOnFileThread(file_system_context_,
-                                   kOrigin,
-                                   kFileSystemType);
+    return file_system_context_->GetQuotaUtil(kFileSystemType)
+        ->GetOriginUsageOnFileThread(
+              file_system_context_.get(), kOrigin, kFileSystemType);
   }
 
   int64 GetFileSizeOnDisk(const char* test_file_path) {
@@ -114,7 +113,7 @@ class FileWriterDelegateTest : public PlatformTest {
 
   scoped_ptr<FileSystemOperationContext> NewOperationContext() {
     FileSystemOperationContext* context =
-      new FileSystemOperationContext(file_system_context_);
+        new FileSystemOperationContext(file_system_context_.get());
     context->set_update_observers(
         *file_system_context_->GetUpdateObservers(kFileSystemType));
     context->set_root_path(dir_.path());
@@ -127,7 +126,7 @@ class FileWriterDelegateTest : public PlatformTest {
       int64 allowed_growth,
       Result* result) {
     SandboxFileStreamWriter* writer = new SandboxFileStreamWriter(
-        file_system_context_,
+        file_system_context_.get(),
         GetFileSystemURL(test_file_path),
         offset,
         *file_system_context_->GetUpdateObservers(kFileSystemType));
diff --git a/webkit/browser/fileapi/local_file_stream_writer_unittest.cc b/webkit/browser/fileapi/local_file_stream_writer_unittest.cc
index 984a114..a4a7c8e 100644
--- a/webkit/browser/fileapi/local_file_stream_writer_unittest.cc
+++ b/webkit/browser/fileapi/local_file_stream_writer_unittest.cc
@@ -37,12 +37,12 @@ class LocalFileStreamWriterTest : public testing::Test {
                           const std::string& data) {
     scoped_refptr<net::StringIOBuffer> buffer(new net::StringIOBuffer(data));
     scoped_refptr<net::DrainableIOBuffer> drainable(
-        new net::DrainableIOBuffer(buffer, buffer->size()));
+        new net::DrainableIOBuffer(buffer.get(), buffer->size()));
 
     while (drainable->BytesRemaining() > 0) {
       net::TestCompletionCallback callback;
-      int result = writer->Write(drainable, drainable->BytesRemaining(),
-                                 callback.callback());
+      int result = writer->Write(
+          drainable.get(), drainable->BytesRemaining(), callback.callback());
       if (result == net::ERR_IO_PENDING)
         result = callback.WaitForResult();
       if (result <= 0)
@@ -146,7 +146,8 @@ TEST_F(LocalFileStreamWriterTest, CancelWrite) {
   scoped_ptr<LocalFileStreamWriter> writer(new LocalFileStreamWriter(path, 0));
 
   scoped_refptr<net::StringIOBuffer> buffer(new net::StringIOBuffer("xxx"));
-  int result = writer->Write(buffer, buffer->size(), base::Bind(&NeverCalled));
+  int result =
+      writer->Write(buffer.get(), buffer->size(), base::Bind(&NeverCalled));
   ASSERT_EQ(net::ERR_IO_PENDING, result);
 
   net::TestCompletionCallback callback;
diff --git a/webkit/browser/fileapi/local_file_system_cross_operation_unittest.cc b/webkit/browser/fileapi/local_file_system_cross_operation_unittest.cc
index 1f1ad04..cb0dfbf 100644
--- a/webkit/browser/fileapi/local_file_system_cross_operation_unittest.cc
+++ b/webkit/browser/fileapi/local_file_system_cross_operation_unittest.cc
@@ -62,11 +62,9 @@ class CrossOperationTestHelper {
         base::MessageLoopProxy::current(),
         NULL /* special storage policy */);
     quota_manager_proxy_ = new quota::MockQuotaManagerProxy(
-        quota_manager_,
-        base::MessageLoopProxy::current());
-    file_system_context_ = CreateFileSystemContextForTesting(
-        quota_manager_proxy_,
-        base_dir);
+        quota_manager_.get(), base::MessageLoopProxy::current());
+    file_system_context_ =
+        CreateFileSystemContextForTesting(quota_manager_proxy_.get(), base_dir);
 
     // Prepare the origin's root directory.
     FileSystemMountPointProvider* mount_point_provider =
@@ -116,12 +114,12 @@ class CrossOperationTestHelper {
 
   base::PlatformFileError Copy(const FileSystemURL& src,
                                const FileSystemURL& dest) {
-    return AsyncFileTestHelper::Copy(file_system_context_, src, dest);
+    return AsyncFileTestHelper::Copy(file_system_context_.get(), src, dest);
   }
 
   base::PlatformFileError Move(const FileSystemURL& src,
                                const FileSystemURL& dest) {
-    return AsyncFileTestHelper::Move(file_system_context_, src, dest);
+    return AsyncFileTestHelper::Move(file_system_context_.get(), src, dest);
   }
 
   base::PlatformFileError SetUpTestCaseFiles(
@@ -188,36 +186,37 @@ class CrossOperationTestHelper {
   base::PlatformFileError ReadDirectory(const FileSystemURL& url,
                                         FileEntryList* entries) {
     return AsyncFileTestHelper::ReadDirectory(
-        file_system_context_, url, entries);
+        file_system_context_.get(), url, entries);
   }
 
   base::PlatformFileError CreateDirectory(const FileSystemURL& url) {
-    return AsyncFileTestHelper::CreateDirectory(
-        file_system_context_, url);
+    return AsyncFileTestHelper::CreateDirectory(file_system_context_.get(),
+                                                url);
   }
 
   base::PlatformFileError CreateFile(const FileSystemURL& url, size_t size) {
     base::PlatformFileError result =
-        AsyncFileTestHelper::CreateFile(file_system_context_, url);
+        AsyncFileTestHelper::CreateFile(file_system_context_.get(), url);
     if (result != base::PLATFORM_FILE_OK)
       return result;
-    return AsyncFileTestHelper::TruncateFile(file_system_context_, url, size);
+    return AsyncFileTestHelper::TruncateFile(
+        file_system_context_.get(), url, size);
   }
 
   bool FileExists(const FileSystemURL& url, int64 expected_size) {
     return AsyncFileTestHelper::FileExists(
-        file_system_context_, url, expected_size);
+        file_system_context_.get(), url, expected_size);
   }
 
   bool DirectoryExists(const FileSystemURL& url) {
-    return AsyncFileTestHelper::DirectoryExists(file_system_context_, url);
+    return AsyncFileTestHelper::DirectoryExists(file_system_context_.get(),
+                                                url);
   }
 
  private:
   void GetUsageAndQuota(FileSystemType type, int64* usage, int64* quota) {
-    quota::QuotaStatusCode status =
-        AsyncFileTestHelper::GetUsageAndQuota(
-            quota_manager_, origin_, type, usage, quota);
+    quota::QuotaStatusCode status = AsyncFileTestHelper::GetUsageAndQuota(
+        quota_manager_.get(), origin_, type, usage, quota);
     ASSERT_EQ(quota::kQuotaStatusOk, status);
   }
 
diff --git a/webkit/browser/fileapi/local_file_system_operation.h b/webkit/browser/fileapi/local_file_system_operation.h
index 9321c44..aaf8c1f 100644
--- a/webkit/browser/fileapi/local_file_system_operation.h
+++ b/webkit/browser/fileapi/local_file_system_operation.h
@@ -166,7 +166,7 @@ class WEBKIT_STORAGE_EXPORT LocalFileSystemOperation
                            base::FilePath* platform_path);
 
   FileSystemContext* file_system_context() const {
-    return file_system_context_;
+    return file_system_context_.get();
   }
 
   FileSystemOperationContext* operation_context() const {
diff --git a/webkit/browser/fileapi/local_file_system_operation_unittest.cc b/webkit/browser/fileapi/local_file_system_operation_unittest.cc
index 19a2467..4a5d585 100644
--- a/webkit/browser/fileapi/local_file_system_operation_unittest.cc
+++ b/webkit/browser/fileapi/local_file_system_operation_unittest.cc
@@ -90,7 +90,7 @@ class LocalFileSystemOperationTest
   }
 
   const ShareableFileReference* shareable_file_ref() const {
-    return shareable_file_ref_;
+    return shareable_file_ref_.get();
   }
 
   quota::MockQuotaManager* quota_manager() {
@@ -225,11 +225,11 @@ class LocalFileSystemOperationTest
 
   void GetUsageAndQuota(int64* usage, int64* quota) {
     quota::QuotaStatusCode status =
-        AsyncFileTestHelper::GetUsageAndQuota(
-            quota_manager_,
-            sandbox_file_system_.origin(),
-            sandbox_file_system_.type(),
-            usage, quota);
+        AsyncFileTestHelper::GetUsageAndQuota(quota_manager_.get(),
+                                              sandbox_file_system_.origin(),
+                                              sandbox_file_system_.type(),
+                                              usage,
+                                              quota);
     base::MessageLoop::current()->RunUntilIdle();
     ASSERT_EQ(quota::kQuotaStatusOk, status);
   }
diff --git a/webkit/browser/fileapi/local_file_system_operation_write_unittest.cc b/webkit/browser/fileapi/local_file_system_operation_write_unittest.cc
index 28849ac..8c908e5 100644
--- a/webkit/browser/fileapi/local_file_system_operation_write_unittest.cc
+++ b/webkit/browser/fileapi/local_file_system_operation_write_unittest.cc
@@ -73,7 +73,7 @@ class LocalFileSystemOperationWriteTest
     file_system_context_ = CreateFileSystemContextForTesting(
         quota_manager_->proxy(), dir_.path());
     url_request_context_.reset(
-        new MockBlobURLRequestContext(file_system_context_));
+        new MockBlobURLRequestContext(file_system_context_.get()));
 
     NewOperation()->CreateFile(
         URLForPath(virtual_path_), true /* exclusive */,
@@ -194,8 +194,8 @@ TEST_F(LocalFileSystemOperationWriteTest, TestWriteZero) {
   GURL blob_url("blob:zero");
   scoped_refptr<webkit_blob::BlobData> blob_data(new webkit_blob::BlobData());
 
-  url_request_context().blob_storage_controller()->AddFinishedBlob(
-      blob_url, blob_data);
+  url_request_context().blob_storage_controller()
+      ->AddFinishedBlob(blob_url, blob_data.get());
 
   NewOperation()->Write(
       &url_request_context(), URLForPath(virtual_path_),
diff --git a/webkit/browser/fileapi/local_file_util_unittest.cc b/webkit/browser/fileapi/local_file_util_unittest.cc
index cac0d4c..9abcffc 100644
--- a/webkit/browser/fileapi/local_file_util_unittest.cc
+++ b/webkit/browser/fileapi/local_file_util_unittest.cc
@@ -49,7 +49,7 @@ class LocalFileUtilTest : public testing::Test {
  protected:
   FileSystemOperationContext* NewContext() {
     FileSystemOperationContext* context =
-      new FileSystemOperationContext(file_system_context_);
+        new FileSystemOperationContext(file_system_context_.get());
     context->set_update_observers(
         *file_system_context_->GetUpdateObservers(kFileSystemType));
     context->set_root_path(data_dir_.path());
@@ -110,7 +110,7 @@ class LocalFileUtilTest : public testing::Test {
   }
 
   FileSystemContext* file_system_context() {
-    return file_system_context_;
+    return file_system_context_.get();
   }
 
  private:
diff --git a/webkit/browser/fileapi/obfuscated_file_util.cc b/webkit/browser/fileapi/obfuscated_file_util.cc
index 3a76111..f976985 100644
--- a/webkit/browser/fileapi/obfuscated_file_util.cc
+++ b/webkit/browser/fileapi/obfuscated_file_util.cc
@@ -1167,7 +1167,7 @@ SandboxDirectoryDatabase* ObfuscatedFileUtil::GetDirectoryDatabase(
 
 base::FilePath ObfuscatedFileUtil::GetDirectoryForOrigin(
     const GURL& origin, bool create, base::PlatformFileError* error_code) {
-  if (special_storage_policy_ &&
+  if (special_storage_policy_.get() &&
       special_storage_policy_->HasIsolatedStorage(origin)) {
     CHECK(isolated_origin_.is_empty() || isolated_origin_ == origin)
         << "multiple origins for an isolated site: "
diff --git a/webkit/browser/fileapi/obfuscated_file_util_unittest.cc b/webkit/browser/fileapi/obfuscated_file_util_unittest.cc
index 0450772..f1fa1b1 100644
--- a/webkit/browser/fileapi/obfuscated_file_util_unittest.cc
+++ b/webkit/browser/fileapi/obfuscated_file_util_unittest.cc
@@ -132,12 +132,11 @@ class ObfuscatedFileUtilTest : public testing::Test {
     scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
         new quota::MockSpecialStoragePolicy();
 
-    quota_manager_ = new quota::QuotaManager(
-        false /* is_incognito */,
-        data_dir_.path(),
-        base::MessageLoopProxy::current(),
-        base::MessageLoopProxy::current(),
-        storage_policy);
+    quota_manager_ = new quota::QuotaManager(false /* is_incognito */,
+                                             data_dir_.path(),
+                                             base::MessageLoopProxy::current(),
+                                             base::MessageLoopProxy::current(),
+                                             storage_policy.get());
 
     // Every time we create a new sandbox_file_system helper,
     // it creates another context, which creates another path manager,
@@ -227,9 +226,12 @@ class ObfuscatedFileUtilTest : public testing::Test {
 
   void GetUsageFromQuotaManager() {
     int64 quota = -1;
-    quota_status_ = AsyncFileTestHelper::GetUsageAndQuota(
-      quota_manager_, origin(), sandbox_file_system_.type(),
-      &usage_, &quota);
+    quota_status_ =
+        AsyncFileTestHelper::GetUsageAndQuota(quota_manager_.get(),
+                                              origin(),
+                                              sandbox_file_system_.type(),
+                                              &usage_,
+                                              &quota);
     EXPECT_EQ(quota::kQuotaStatusOk, quota_status_);
   }
 
diff --git a/webkit/browser/fileapi/sandbox_file_system_test_helper.cc b/webkit/browser/fileapi/sandbox_file_system_test_helper.cc
index 5abcd45..d55b013 100644
--- a/webkit/browser/fileapi/sandbox_file_system_test_helper.cc
+++ b/webkit/browser/fileapi/sandbox_file_system_test_helper.cc
@@ -91,8 +91,8 @@ FileSystemURL SandboxFileSystemTestHelper::CreateURL(
 }
 
 int64 SandboxFileSystemTestHelper::GetCachedOriginUsage() const {
-  return file_system_context_->GetQuotaUtil(type_)->GetOriginUsageOnFileThread(
-      file_system_context_, origin_, type_);
+  return file_system_context_->GetQuotaUtil(type_)
+      ->GetOriginUsageOnFileThread(file_system_context_.get(), origin_, type_);
 }
 
 int64 SandboxFileSystemTestHelper::ComputeCurrentOriginUsage() {
@@ -133,7 +133,7 @@ FileSystemUsageCache* SandboxFileSystemTestHelper::usage_cache() {
 }
 
 void SandboxFileSystemTestHelper::SetUpFileSystem() {
-  DCHECK(file_system_context_);
+  DCHECK(file_system_context_.get());
   DCHECK(file_system_context_->sandbox_provider()->CanHandleType(type_));
 
   file_util_ = file_system_context_->GetFileUtil(type_);
diff --git a/webkit/browser/fileapi/sandbox_mount_point_provider.cc b/webkit/browser/fileapi/sandbox_mount_point_provider.cc
index 49cbfe8..b9789fb 100644
--- a/webkit/browser/fileapi/sandbox_mount_point_provider.cc
+++ b/webkit/browser/fileapi/sandbox_mount_point_provider.cc
@@ -171,7 +171,8 @@ SandboxMountPointProvider::SandboxMountPointProvider(
   AccessObserverList::Source access_observers_src;
 
   if (enable_usage_tracking_) {
-    update_observers_src.AddObserver(quota_observer_.get(), file_task_runner_);
+    update_observers_src.AddObserver(quota_observer_.get(),
+                                     file_task_runner_.get());
     access_observers_src.AddObserver(quota_observer_.get(), NULL);
   }
 
@@ -317,7 +318,7 @@ FileSystemOperation* SandboxMountPointProvider::CreateFileSystemOperation(
   operation_context->set_update_observers(update_observers_);
   operation_context->set_access_observers(access_observers_);
 
-  if (special_storage_policy_ &&
+  if (special_storage_policy_.get() &&
       special_storage_policy_->IsStorageUnlimited(url.origin())) {
     operation_context->set_quota_limit_type(quota::kQuotaLimitTypeUnlimited);
   } else {
diff --git a/webkit/browser/fileapi/sandbox_quota_observer.cc b/webkit/browser/fileapi/sandbox_quota_observer.cc
index 05fa511..9098db5 100644
--- a/webkit/browser/fileapi/sandbox_quota_observer.cc
+++ b/webkit/browser/fileapi/sandbox_quota_observer.cc
@@ -42,7 +42,7 @@ void SandboxQuotaObserver::OnUpdate(const FileSystemURL& url,
   DCHECK(SandboxMountPointProvider::IsSandboxType(url.type()));
   DCHECK(update_notify_runner_->RunsTasksOnCurrentThread());
 
-  if (quota_manager_proxy_) {
+  if (quota_manager_proxy_.get()) {
     quota_manager_proxy_->NotifyStorageModified(
         quota::QuotaClient::kFileSystem,
         url.origin(),
@@ -83,7 +83,7 @@ void SandboxQuotaObserver::OnEndUpdate(const FileSystemURL& url) {
 
 void SandboxQuotaObserver::OnAccess(const FileSystemURL& url) {
   DCHECK(SandboxMountPointProvider::IsSandboxType(url.type()));
-  if (quota_manager_proxy_) {
+  if (quota_manager_proxy_.get()) {
     quota_manager_proxy_->NotifyStorageAccessed(
         quota::QuotaClient::kFileSystem,
         url.origin(),
@@ -95,10 +95,11 @@ void SandboxQuotaObserver::SetUsageCacheEnabled(
     const GURL& origin,
     FileSystemType type,
     bool enabled) {
-  if (quota_manager_proxy_) {
+  if (quota_manager_proxy_.get()) {
     quota_manager_proxy_->SetUsageCacheEnabled(
         quota::QuotaClient::kFileSystem,
-        origin, FileSystemTypeToQuotaStorageType(type),
+        origin,
+        FileSystemTypeToQuotaStorageType(type),
         enabled);
   }
 }
diff --git a/webkit/browser/fileapi/syncable/canned_syncable_file_system.cc b/webkit/browser/fileapi/syncable/canned_syncable_file_system.cc
index 33b4e3e..2913d69 100644
--- a/webkit/browser/fileapi/syncable/canned_syncable_file_system.cc
+++ b/webkit/browser/fileapi/syncable/canned_syncable_file_system.cc
@@ -201,20 +201,19 @@ void CannedSyncableFileSystem::SetUp() {
   scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
       new quota::MockSpecialStoragePolicy();
 
-  quota_manager_ = new QuotaManager(
-      false /* is_incognito */,
-      data_dir_.path(),
-      io_task_runner_,
-      base::MessageLoopProxy::current(),
-      storage_policy);
+  quota_manager_ = new QuotaManager(false /* is_incognito */,
+                                    data_dir_.path(),
+                                    io_task_runner_.get(),
+                                    base::MessageLoopProxy::current(),
+                                    storage_policy.get());
 
   file_system_context_ = new FileSystemContext(
-      make_scoped_ptr(new fileapi::FileSystemTaskRunners(
-          io_task_runner_,
-          file_task_runner_,
-          file_task_runner_)),
+      make_scoped_ptr(
+          new fileapi::FileSystemTaskRunners(io_task_runner_.get(),
+                                             file_task_runner_.get(),
+                                             file_task_runner_.get())),
       fileapi::ExternalMountPoints::CreateRefCounted().get(),
-      storage_policy,
+      storage_policy.get(),
       quota_manager_->proxy(),
       ScopedVector<fileapi::FileSystemMountPointProvider>(),
       data_dir_.path(),
@@ -233,8 +232,8 @@ void CannedSyncableFileSystem::TearDown() {
   SetEnableSyncFSDirectoryOperation(false);
 
   // Make sure we give some more time to finish tasks on other threads.
-  EnsureLastTaskRuns(io_task_runner_);
-  EnsureLastTaskRuns(file_task_runner_);
+  EnsureLastTaskRuns(io_task_runner_.get());
+  EnsureLastTaskRuns(file_task_runner_.get());
 }
 
 FileSystemURL CannedSyncableFileSystem::URL(const std::string& path) const {
@@ -256,11 +255,11 @@ PlatformFileError CannedSyncableFileSystem::OpenFileSystem() {
   base::MessageLoop::current()->Run();
   if (file_system_context_->sync_context()) {
     // Register 'this' as a sync status observer.
-    RunOnThread(io_task_runner_,
-                FROM_HERE,
-                base::Bind(
-                    &CannedSyncableFileSystem::InitializeSyncStatusObserver,
-                    base::Unretained(this)));
+    RunOnThread(
+        io_task_runner_.get(),
+        FROM_HERE,
+        base::Bind(&CannedSyncableFileSystem::InitializeSyncStatusObserver,
+                   base::Unretained(this)));
   }
   return result_;
 }
@@ -279,9 +278,12 @@ SyncStatusCode CannedSyncableFileSystem::MaybeInitializeFileSystemContext(
     LocalFileSyncContext* sync_context) {
   DCHECK(sync_context);
   sync_status_ = sync_file_system::SYNC_STATUS_UNKNOWN;
-  VerifySameTaskRunner(io_task_runner_, sync_context->io_task_runner_);
+  VerifySameTaskRunner(io_task_runner_.get(),
+                       sync_context->io_task_runner_.get());
   sync_context->MaybeInitializeFileSystemContext(
-      origin_, service_name_, file_system_context_,
+      origin_,
+      service_name_,
+      file_system_context_.get(),
       base::Bind(&CannedSyncableFileSystem::DidInitializeFileSystemContext,
                  base::Unretained(this)));
   base::MessageLoop::current()->Run();
@@ -291,46 +293,54 @@ SyncStatusCode CannedSyncableFileSystem::MaybeInitializeFileSystemContext(
 PlatformFileError CannedSyncableFileSystem::CreateDirectory(
     const FileSystemURL& url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCreateDirectory,
-                 base::Unretained(this), url));
+                 base::Unretained(this),
+                 url));
 }
 
 PlatformFileError CannedSyncableFileSystem::CreateFile(
     const FileSystemURL& url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCreateFile,
-                 base::Unretained(this), url));
+                 base::Unretained(this),
+                 url));
 }
 
 PlatformFileError CannedSyncableFileSystem::Copy(
     const FileSystemURL& src_url, const FileSystemURL& dest_url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCopy,
-                 base::Unretained(this), src_url, dest_url));
+                 base::Unretained(this),
+                 src_url,
+                 dest_url));
 }
 
 PlatformFileError CannedSyncableFileSystem::Move(
     const FileSystemURL& src_url, const FileSystemURL& dest_url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoMove,
-                 base::Unretained(this), src_url, dest_url));
+                 base::Unretained(this),
+                 src_url,
+                 dest_url));
 }
 
 PlatformFileError CannedSyncableFileSystem::TruncateFile(
     const FileSystemURL& url, int64 size) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoTruncateFile,
-                 base::Unretained(this), url, size));
+                 base::Unretained(this),
+                 url,
+                 size));
 }
 
 PlatformFileError CannedSyncableFileSystem::TouchFile(
@@ -338,48 +348,56 @@ PlatformFileError CannedSyncableFileSystem::TouchFile(
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoTouchFile,
-                 base::Unretained(this), url,
-                 last_access_time, last_modified_time));
+                 base::Unretained(this),
+                 url,
+                 last_access_time,
+                 last_modified_time));
 }
 
 PlatformFileError CannedSyncableFileSystem::Remove(
     const FileSystemURL& url, bool recursive) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoRemove,
-                 base::Unretained(this), url, recursive));
+                 base::Unretained(this),
+                 url,
+                 recursive));
 }
 
 PlatformFileError CannedSyncableFileSystem::FileExists(
     const FileSystemURL& url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoFileExists,
-                 base::Unretained(this), url));
+                 base::Unretained(this),
+                 url));
 }
 
 PlatformFileError CannedSyncableFileSystem::DirectoryExists(
     const FileSystemURL& url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoDirectoryExists,
-                 base::Unretained(this), url));
+                 base::Unretained(this),
+                 url));
 }
 
 PlatformFileError CannedSyncableFileSystem::VerifyFile(
     const FileSystemURL& url,
     const std::string& expected_data) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoVerifyFile,
-                 base::Unretained(this), url, expected_data));
+                 base::Unretained(this),
+                 url,
+                 expected_data));
 }
 
 PlatformFileError CannedSyncableFileSystem::GetMetadata(
@@ -387,53 +405,63 @@ PlatformFileError CannedSyncableFileSystem::GetMetadata(
     base::PlatformFileInfo* info,
     base::FilePath* platform_path) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoGetMetadata,
-                 base::Unretained(this), url, info, platform_path));
+                 base::Unretained(this),
+                 url,
+                 info,
+                 platform_path));
 }
 
 int64 CannedSyncableFileSystem::Write(
     net::URLRequestContext* url_request_context,
     const FileSystemURL& url, const GURL& blob_url) {
-  return RunOnThread<int64>(
-      io_task_runner_,
-      FROM_HERE,
-      base::Bind(&CannedSyncableFileSystem::DoWrite,
-                 base::Unretained(this), url_request_context, url, blob_url));
+  return RunOnThread<int64>(io_task_runner_.get(),
+                            FROM_HERE,
+                            base::Bind(&CannedSyncableFileSystem::DoWrite,
+                                       base::Unretained(this),
+                                       url_request_context,
+                                       url,
+                                       blob_url));
 }
 
 int64 CannedSyncableFileSystem::WriteString(
     const FileSystemURL& url, const std::string& data) {
-  return RunOnThread<int64>(
-      io_task_runner_,
-      FROM_HERE,
-      base::Bind(&CannedSyncableFileSystem::DoWriteString,
-                 base::Unretained(this), url, data));
+  return RunOnThread<int64>(io_task_runner_.get(),
+                            FROM_HERE,
+                            base::Bind(&CannedSyncableFileSystem::DoWriteString,
+                                       base::Unretained(this),
+                                       url,
+                                       data));
 }
 
 PlatformFileError CannedSyncableFileSystem::DeleteFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileSystemContext::DeleteFileSystem,
-                 file_system_context_, origin_, type_));
+                 file_system_context_,
+                 origin_,
+                 type_));
 }
 
 quota::QuotaStatusCode CannedSyncableFileSystem::GetUsageAndQuota(
     int64* usage, int64* quota) {
   return RunOnThread<quota::QuotaStatusCode>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoGetUsageAndQuota,
-                 base::Unretained(this), usage, quota));
+                 base::Unretained(this),
+                 usage,
+                 quota));
 }
 
 void CannedSyncableFileSystem::GetChangedURLsInTracker(
     FileSystemURLSet* urls) {
   return RunOnThread(
-      file_task_runner_,
+      file_task_runner_.get(),
       FROM_HERE,
       base::Bind(&LocalFileChangeTracker::GetAllChangedURLs,
                  base::Unretained(file_system_context_->change_tracker()),
@@ -443,7 +471,7 @@ void CannedSyncableFileSystem::GetChangedURLsInTracker(
 void CannedSyncableFileSystem::ClearChangeForURLInTracker(
     const FileSystemURL& url) {
   return RunOnThread(
-      file_task_runner_,
+      file_task_runner_.get(),
       FROM_HERE,
       base::Bind(&LocalFileChangeTracker::ClearChangesForURL,
                  base::Unretained(file_system_context_->change_tracker()),
@@ -568,7 +596,7 @@ void CannedSyncableFileSystem::DoWriteString(
     const std::string& data,
     const WriteCallback& callback) {
   MockBlobURLRequestContext* url_request_context(
-      new MockBlobURLRequestContext(file_system_context_));
+      new MockBlobURLRequestContext(file_system_context_.get()));
   const GURL blob_url(std::string("blob:") + data);
   WriteHelper* helper = new WriteHelper(url_request_context, blob_url, data);
   NewOperation()->Write(url_request_context, url, blob_url, 0,
diff --git a/webkit/browser/fileapi/syncable/local_file_change_tracker_unittest.cc b/webkit/browser/fileapi/syncable/local_file_change_tracker_unittest.cc
index 834389d..a454b8d 100644
--- a/webkit/browser/fileapi/syncable/local_file_change_tracker_unittest.cc
+++ b/webkit/browser/fileapi/syncable/local_file_change_tracker_unittest.cc
@@ -45,12 +45,13 @@ class LocalFileChangeTrackerTest : public testing::Test {
 
     sync_context_ = new LocalFileSyncContext(base::MessageLoopProxy::current(),
                                              base::MessageLoopProxy::current());
-    ASSERT_EQ(sync_file_system::SYNC_STATUS_OK,
-              file_system_.MaybeInitializeFileSystemContext(sync_context_));
+    ASSERT_EQ(
+        sync_file_system::SYNC_STATUS_OK,
+        file_system_.MaybeInitializeFileSystemContext(sync_context_.get()));
   }
 
   virtual void TearDown() OVERRIDE {
-    if (sync_context_)
+    if (sync_context_.get())
       sync_context_->ShutdownOnUIThread();
     sync_context_ = NULL;
 
diff --git a/webkit/browser/fileapi/syncable/local_file_sync_context_unittest.cc b/webkit/browser/fileapi/syncable/local_file_sync_context_unittest.cc
index 539d43e..ad4beb2 100644
--- a/webkit/browser/fileapi/syncable/local_file_sync_context_unittest.cc
+++ b/webkit/browser/fileapi/syncable/local_file_sync_context_unittest.cc
@@ -207,21 +207,24 @@ class LocalFileSyncContextTest : public testing::Test {
 };
 
 TEST_F(LocalFileSyncContextTest, ConstructAndDestruct) {
-  sync_context_ = new LocalFileSyncContext(
-      ui_task_runner_, io_task_runner_);
+  sync_context_ =
+      new LocalFileSyncContext(ui_task_runner_.get(), io_task_runner_.get());
   sync_context_->ShutdownOnUIThread();
 }
 
 TEST_F(LocalFileSyncContextTest, InitializeFileSystemContext) {
-  CannedSyncableFileSystem file_system(GURL(kOrigin1), kServiceName,
-                                       io_task_runner_, file_task_runner_);
+  CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                       kServiceName,
+                                       io_task_runner_.get(),
+                                       file_task_runner_.get());
   file_system.SetUp();
 
-  sync_context_ = new LocalFileSyncContext(ui_task_runner_, io_task_runner_);
+  sync_context_ =
+      new LocalFileSyncContext(ui_task_runner_.get(), io_task_runner_.get());
 
   // Initializes file_system using |sync_context_|.
   EXPECT_EQ(SYNC_STATUS_OK,
-            file_system.MaybeInitializeFileSystemContext(sync_context_));
+            file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
 
   // Make sure everything's set up for file_system to be able to handle
   // syncable file system operations.
@@ -232,7 +235,7 @@ TEST_F(LocalFileSyncContextTest, InitializeFileSystemContext) {
 
   // Calling MaybeInitialize for the same context multiple times must be ok.
   EXPECT_EQ(SYNC_STATUS_OK,
-            file_system.MaybeInitializeFileSystemContext(sync_context_));
+            file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   EXPECT_EQ(sync_context_.get(),
             file_system.file_system_context()->sync_context());
 
@@ -254,20 +257,25 @@ TEST_F(LocalFileSyncContextTest, InitializeFileSystemContext) {
 }
 
 TEST_F(LocalFileSyncContextTest, MultipleFileSystemContexts) {
-  CannedSyncableFileSystem file_system1(GURL(kOrigin1), kServiceName,
-                                        io_task_runner_, file_task_runner_);
-  CannedSyncableFileSystem file_system2(GURL(kOrigin2), kServiceName,
-                                        io_task_runner_, file_task_runner_);
+  CannedSyncableFileSystem file_system1(GURL(kOrigin1),
+                                        kServiceName,
+                                        io_task_runner_.get(),
+                                        file_task_runner_.get());
+  CannedSyncableFileSystem file_system2(GURL(kOrigin2),
+                                        kServiceName,
+                                        io_task_runner_.get(),
+                                        file_task_runner_.get());
   file_system1.SetUp();
   file_system2.SetUp();
 
-  sync_context_ = new LocalFileSyncContext(ui_task_runner_, io_task_runner_);
+  sync_context_ =
+      new LocalFileSyncContext(ui_task_runner_.get(), io_task_runner_.get());
 
   // Initializes file_system1 and file_system2.
   EXPECT_EQ(SYNC_STATUS_OK,
-            file_system1.MaybeInitializeFileSystemContext(sync_context_));
+            file_system1.MaybeInitializeFileSystemContext(sync_context_.get()));
   EXPECT_EQ(SYNC_STATUS_OK,
-            file_system2.MaybeInitializeFileSystemContext(sync_context_));
+            file_system2.MaybeInitializeFileSystemContext(sync_context_.get()));
 
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system1.OpenFileSystem());
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system2.OpenFileSystem());
@@ -340,12 +348,15 @@ TEST_F(LocalFileSyncContextTest, MultipleFileSystemContexts) {
 #define MAYBE_PrepareSyncWhileWriting PrepareSyncWhileWriting
 #endif
 TEST_F(LocalFileSyncContextTest, MAYBE_PrepareSyncWhileWriting) {
-  CannedSyncableFileSystem file_system(GURL(kOrigin1), kServiceName,
-                                       io_task_runner_, file_task_runner_);
+  CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                       kServiceName,
+                                       io_task_runner_.get(),
+                                       file_task_runner_.get());
   file_system.SetUp();
-  sync_context_ = new LocalFileSyncContext(ui_task_runner_, io_task_runner_);
+  sync_context_ =
+      new LocalFileSyncContext(ui_task_runner_.get(), io_task_runner_.get());
   EXPECT_EQ(SYNC_STATUS_OK,
-            file_system.MaybeInitializeFileSystemContext(sync_context_));
+            file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
 
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
 
@@ -397,13 +408,16 @@ TEST_F(LocalFileSyncContextTest, MAYBE_PrepareSyncWhileWriting) {
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForDeletion) {
-  CannedSyncableFileSystem file_system(GURL(kOrigin1), kServiceName,
-                                       io_task_runner_, file_task_runner_);
+  CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                       kServiceName,
+                                       io_task_runner_.get(),
+                                       file_task_runner_.get());
   file_system.SetUp();
 
-  sync_context_ = new LocalFileSyncContext(ui_task_runner_, io_task_runner_);
+  sync_context_ =
+      new LocalFileSyncContext(ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
-            file_system.MaybeInitializeFileSystemContext(sync_context_));
+            file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   ASSERT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
 
   // Record the initial usage (likely 0).
@@ -484,13 +498,16 @@ TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForAddOrUpdate) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
-  CannedSyncableFileSystem file_system(GURL(kOrigin1), kServiceName,
-                                       io_task_runner_, file_task_runner_);
+  CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                       kServiceName,
+                                       io_task_runner_.get(),
+                                       file_task_runner_.get());
   file_system.SetUp();
 
-  sync_context_ = new LocalFileSyncContext(ui_task_runner_, io_task_runner_);
+  sync_context_ =
+      new LocalFileSyncContext(ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
-            file_system.MaybeInitializeFileSystemContext(sync_context_));
+            file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   ASSERT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
 
   const FileSystemURL kFile1(file_system.URL("file1"));
@@ -631,13 +648,16 @@ TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForAddOrUpdate_NoParent) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
-  CannedSyncableFileSystem file_system(GURL(kOrigin1), kServiceName,
-                                       io_task_runner_, file_task_runner_);
+  CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                       kServiceName,
+                                       io_task_runner_.get(),
+                                       file_task_runner_.get());
   file_system.SetUp();
 
-  sync_context_ = new LocalFileSyncContext(ui_task_runner_, io_task_runner_);
+  sync_context_ =
+      new LocalFileSyncContext(ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
-            file_system.MaybeInitializeFileSystemContext(sync_context_));
+            file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   ASSERT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
 
   const char kTestFileData[] = "Lorem ipsum!";
diff --git a/webkit/browser/fileapi/syncable/syncable_file_operation_runner_unittest.cc b/webkit/browser/fileapi/syncable/syncable_file_operation_runner_unittest.cc
index 77cbb1b..03f1a3d 100644
--- a/webkit/browser/fileapi/syncable/syncable_file_operation_runner_unittest.cc
+++ b/webkit/browser/fileapi/syncable/syncable_file_operation_runner_unittest.cc
@@ -60,8 +60,9 @@ class SyncableFileOperationRunnerTest : public testing::Test {
     file_system_.SetUp();
     sync_context_ = new LocalFileSyncContext(base::MessageLoopProxy::current(),
                                              base::MessageLoopProxy::current());
-    ASSERT_EQ(SYNC_STATUS_OK,
-              file_system_.MaybeInitializeFileSystemContext(sync_context_));
+    ASSERT_EQ(
+        SYNC_STATUS_OK,
+        file_system_.MaybeInitializeFileSystemContext(sync_context_.get()));
 
     ASSERT_EQ(base::PLATFORM_FILE_OK, file_system_.OpenFileSystem());
     ASSERT_EQ(base::PLATFORM_FILE_OK,
@@ -69,7 +70,7 @@ class SyncableFileOperationRunnerTest : public testing::Test {
   }
 
   virtual void TearDown() OVERRIDE {
-    if (sync_context_)
+    if (sync_context_.get())
       sync_context_->ShutdownOnUIThread();
     sync_context_ = NULL;
 
diff --git a/webkit/browser/fileapi/syncable/syncable_file_system_unittest.cc b/webkit/browser/fileapi/syncable/syncable_file_system_unittest.cc
index 36e5b6a..f6bbd85 100644
--- a/webkit/browser/fileapi/syncable/syncable_file_system_unittest.cc
+++ b/webkit/browser/fileapi/syncable/syncable_file_system_unittest.cc
@@ -43,12 +43,13 @@ class SyncableFileSystemTest : public testing::Test {
 
     sync_context_ = new LocalFileSyncContext(base::MessageLoopProxy::current(),
                                              base::MessageLoopProxy::current());
-    ASSERT_EQ(sync_file_system::SYNC_STATUS_OK,
-              file_system_.MaybeInitializeFileSystemContext(sync_context_));
+    ASSERT_EQ(
+        sync_file_system::SYNC_STATUS_OK,
+        file_system_.MaybeInitializeFileSystemContext(sync_context_.get()));
   }
 
   virtual void TearDown() {
-    if (sync_context_)
+    if (sync_context_.get())
       sync_context_->ShutdownOnUIThread();
     sync_context_ = NULL;
 
diff --git a/webkit/browser/fileapi/syncable/syncable_file_system_util_unittest.cc b/webkit/browser/fileapi/syncable/syncable_file_system_util_unittest.cc
index d62deb5..ba35336 100644
--- a/webkit/browser/fileapi/syncable/syncable_file_system_util_unittest.cc
+++ b/webkit/browser/fileapi/syncable/syncable_file_system_util_unittest.cc
@@ -132,7 +132,7 @@ TEST(SyncableFileSystemUtilTest, SerializeBeforeOpenFileSystem) {
   EXPECT_FALSE(deserialized.is_valid());
 
   ASSERT_EQ(sync_file_system::SYNC_STATUS_OK,
-            file_system.MaybeInitializeFileSystemContext(sync_context));
+            file_system.MaybeInitializeFileSystemContext(sync_context.get()));
 
   // After initialization this should be ok (even before opening the file
   // system).
diff --git a/webkit/browser/fileapi/test_mount_point_provider.cc b/webkit/browser/fileapi/test_mount_point_provider.cc
index 0c87035..3b6fb2f 100644
--- a/webkit/browser/fileapi/test_mount_point_provider.cc
+++ b/webkit/browser/fileapi/test_mount_point_provider.cc
@@ -80,7 +80,7 @@ TestMountPointProvider::TestMountPointProvider(
       quota_util_(new QuotaUtil),
       require_copy_or_move_validator_(false) {
   UpdateObserverList::Source source;
-  source.AddObserver(quota_util_.get(), task_runner_);
+  source.AddObserver(quota_util_.get(), task_runner_.get());
   observers_ = UpdateObserverList(source);
 }
 
diff --git a/webkit/browser/fileapi/transient_file_util_unittest.cc b/webkit/browser/fileapi/transient_file_util_unittest.cc
index 58a8046..66be6db 100644
--- a/webkit/browser/fileapi/transient_file_util_unittest.cc
+++ b/webkit/browser/fileapi/transient_file_util_unittest.cc
@@ -59,7 +59,7 @@ class TransientFileUtilTest : public testing::Test {
 
   scoped_ptr<FileSystemOperationContext> NewOperationContext() {
     return make_scoped_ptr(
-        new FileSystemOperationContext(file_system_context_));
+        new FileSystemOperationContext(file_system_context_.get()));
   }
 
   FileSystemFileUtil* file_util() { return transient_file_util_.get(); }
diff --git a/webkit/browser/fileapi/upload_file_system_file_element_reader_unittest.cc b/webkit/browser/fileapi/upload_file_system_file_element_reader_unittest.cc
index 6337d50..fc93000 100644
--- a/webkit/browser/fileapi/upload_file_system_file_element_reader_unittest.cc
+++ b/webkit/browser/fileapi/upload_file_system_file_element_reader_unittest.cc
@@ -55,9 +55,12 @@ class UploadFileSystemFileElementReaderTest : public testing::Test {
                         &file_modification_time_);
 
     // Create and initialize a reader.
-    reader_.reset(new UploadFileSystemFileElementReader(
-        file_system_context_, file_url_, 0, kuint64max,
-        file_modification_time_));
+    reader_.reset(
+        new UploadFileSystemFileElementReader(file_system_context_.get(),
+                                              file_url_,
+                                              0,
+                                              kuint64max,
+                                              file_modification_time_));
     net::TestCompletionCallback callback;
     ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(callback.callback()));
     EXPECT_EQ(net::OK, callback.WaitForResult());
@@ -84,7 +87,7 @@ class UploadFileSystemFileElementReaderTest : public testing::Test {
     fileapi::FileSystemFileUtil* file_util =
         file_system_context_->GetFileUtil(kFileSystemType);
 
-    fileapi::FileSystemOperationContext context(file_system_context_);
+    fileapi::FileSystemOperationContext context(file_system_context_.get());
     context.set_allowed_bytes_growth(1024);
 
     base::PlatformFile handle = base::kInvalidPlatformFileValue;
@@ -131,13 +134,13 @@ TEST_F(UploadFileSystemFileElementReaderTest, ReadAll) {
   scoped_refptr<net::IOBufferWithSize> buf =
       new net::IOBufferWithSize(file_data_.size());
   net::TestCompletionCallback read_callback;
-  ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(),
-                                               read_callback.callback()));
+  ASSERT_EQ(net::ERR_IO_PENDING,
+            reader_->Read(buf.get(), buf->size(), read_callback.callback()));
   EXPECT_EQ(buf->size(), read_callback.WaitForResult());
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data()));
   // Try to read again.
-  EXPECT_EQ(0, reader_->Read(buf, buf->size(), read_callback.callback()));
+  EXPECT_EQ(0, reader_->Read(buf.get(), buf->size(), read_callback.callback()));
 }
 
 TEST_F(UploadFileSystemFileElementReaderTest, ReadPartially) {
@@ -148,16 +151,16 @@ TEST_F(UploadFileSystemFileElementReaderTest, ReadPartially) {
       new net::IOBufferWithSize(kHalfSize);
 
   net::TestCompletionCallback read_callback1;
-  ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(),
-                                               read_callback1.callback()));
+  ASSERT_EQ(net::ERR_IO_PENDING,
+            reader_->Read(buf.get(), buf->size(), read_callback1.callback()));
   EXPECT_EQ(buf->size(), read_callback1.WaitForResult());
   EXPECT_EQ(file_data_.size() - buf->size(), reader_->BytesRemaining());
   EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.begin() + kHalfSize,
                          buf->data()));
 
   net::TestCompletionCallback read_callback2;
-  EXPECT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(),
-                                               read_callback2.callback()));
+  EXPECT_EQ(net::ERR_IO_PENDING,
+            reader_->Read(buf.get(), buf->size(), read_callback2.callback()));
   EXPECT_EQ(buf->size(), read_callback2.WaitForResult());
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_TRUE(std::equal(file_data_.begin() + kHalfSize, file_data_.end(),
@@ -169,8 +172,8 @@ TEST_F(UploadFileSystemFileElementReaderTest, ReadTooMuch) {
   scoped_refptr<net::IOBufferWithSize> buf =
       new net::IOBufferWithSize(kTooLargeSize);
   net::TestCompletionCallback read_callback;
-  ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(),
-                                               read_callback.callback()));
+  ASSERT_EQ(net::ERR_IO_PENDING,
+            reader_->Read(buf.get(), buf->size(), read_callback.callback()));
   EXPECT_EQ(static_cast<int>(file_data_.size()), read_callback.WaitForResult());
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data()));
@@ -182,8 +185,8 @@ TEST_F(UploadFileSystemFileElementReaderTest, MultipleInit) {
 
   // Read all.
   net::TestCompletionCallback read_callback1;
-  ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(),
-                                               read_callback1.callback()));
+  ASSERT_EQ(net::ERR_IO_PENDING,
+            reader_->Read(buf.get(), buf->size(), read_callback1.callback()));
   EXPECT_EQ(buf->size(), read_callback1.WaitForResult());
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data()));
@@ -197,8 +200,8 @@ TEST_F(UploadFileSystemFileElementReaderTest, MultipleInit) {
 
   // Read again.
   net::TestCompletionCallback read_callback2;
-  ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(),
-                                               read_callback2.callback()));
+  ASSERT_EQ(net::ERR_IO_PENDING,
+            reader_->Read(buf.get(), buf->size(), read_callback2.callback()));
   EXPECT_EQ(buf->size(), read_callback2.WaitForResult());
   EXPECT_EQ(0U, reader_->BytesRemaining());
   EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data()));
@@ -210,8 +213,8 @@ TEST_F(UploadFileSystemFileElementReaderTest, InitDuringAsyncOperation) {
 
   // Start reading all.
   net::TestCompletionCallback read_callback1;
-  EXPECT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(),
-                                               read_callback1.callback()));
+  EXPECT_EQ(net::ERR_IO_PENDING,
+            reader_->Read(buf.get(), buf->size(), read_callback1.callback()));
 
   // Call Init to cancel the previous read.
   net::TestCompletionCallback init_callback1;
@@ -228,8 +231,8 @@ TEST_F(UploadFileSystemFileElementReaderTest, InitDuringAsyncOperation) {
   scoped_refptr<net::IOBufferWithSize> buf2 =
       new net::IOBufferWithSize(file_data_.size() / 2);
   net::TestCompletionCallback read_callback2;
-  EXPECT_EQ(net::ERR_IO_PENDING, reader_->Read(buf2, buf2->size(),
-                                               read_callback2.callback()));
+  EXPECT_EQ(net::ERR_IO_PENDING,
+            reader_->Read(buf2.get(), buf2->size(), read_callback2.callback()));
   EXPECT_EQ(buf2->size(), read_callback2.WaitForResult());
   EXPECT_EQ(file_data_.size() - buf2->size(), reader_->BytesRemaining());
   EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.begin() + buf2->size(),
@@ -244,7 +247,7 @@ TEST_F(UploadFileSystemFileElementReaderTest, Range) {
   const int kOffset = 2;
   const int kLength = file_data_.size() - kOffset * 3;
   reader_.reset(new UploadFileSystemFileElementReader(
-      file_system_context_, file_url_, kOffset, kLength, base::Time()));
+      file_system_context_.get(), file_url_, kOffset, kLength, base::Time()));
   net::TestCompletionCallback init_callback;
   ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback()));
   EXPECT_EQ(net::OK, init_callback.WaitForResult());
@@ -252,8 +255,8 @@ TEST_F(UploadFileSystemFileElementReaderTest, Range) {
   EXPECT_EQ(static_cast<uint64>(kLength), reader_->BytesRemaining());
   scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(kLength);
   net::TestCompletionCallback read_callback;
-  ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(),
-                                               read_callback.callback()));
+  ASSERT_EQ(net::ERR_IO_PENDING,
+            reader_->Read(buf.get(), buf->size(), read_callback.callback()));
   EXPECT_EQ(kLength, read_callback.WaitForResult());
   EXPECT_TRUE(std::equal(file_data_.begin() + kOffset,
                          file_data_.begin() + kOffset + kLength,
@@ -264,9 +267,12 @@ TEST_F(UploadFileSystemFileElementReaderTest, FileChanged) {
   // Expect one second before the actual modification time to simulate change.
   const base::Time expected_modification_time =
       file_modification_time_ - base::TimeDelta::FromSeconds(1);
-  reader_.reset(new UploadFileSystemFileElementReader(
-      file_system_context_, file_url_, 0, kuint64max,
-      expected_modification_time));
+  reader_.reset(
+      new UploadFileSystemFileElementReader(file_system_context_.get(),
+                                            file_url_,
+                                            0,
+                                            kuint64max,
+                                            expected_modification_time));
   net::TestCompletionCallback init_callback;
   ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback()));
   EXPECT_EQ(net::ERR_UPLOAD_FILE_CHANGED, init_callback.WaitForResult());
@@ -275,7 +281,7 @@ TEST_F(UploadFileSystemFileElementReaderTest, FileChanged) {
 TEST_F(UploadFileSystemFileElementReaderTest, WrongURL) {
   const GURL wrong_url = GetFileSystemURL("wrong_file_name.dat");
   reader_.reset(new UploadFileSystemFileElementReader(
-      file_system_context_, wrong_url, 0, kuint64max, base::Time()));
+      file_system_context_.get(), wrong_url, 0, kuint64max, base::Time()));
   net::TestCompletionCallback init_callback;
   ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback()));
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, init_callback.WaitForResult());