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

webkit/browser/fileapi/local_file_system_cross_operation_unittest.cc

 // Copyright (c) 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 <map>
 #include <queue>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 44 matching lines @@
 
   void SetUp() {
     ASSERT_TRUE(base_.CreateUniqueTempDir());
     base::FilePath base_dir = base_.path();
     quota_manager_ = new quota::MockQuotaManager(
         false /* is_incognito */, base_dir,
         base::MessageLoopProxy::current(),
         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 =
         file_system_context_->GetMountPointProvider(src_type_);
     mount_point_provider->OpenFileSystem(
         origin_, src_type_,
         OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&ExpectOk));
     mount_point_provider =
         file_system_context_->GetMountPointProvider(dest_type_);
@@ skipping 29 matching lines @@
         origin_, src_type_, base::FilePath::FromUTF8Unsafe(path));
   }
 
   FileSystemURL DestURL(const std::string& path) {
     return file_system_context_->CreateCrackedFileSystemURL(
         origin_, dest_type_, base::FilePath::FromUTF8Unsafe(path));
   }
 
   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(
       const FileSystemURL& root,
       const test::TestCaseRecord* const test_cases,
       size_t test_case_size) {
     base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
     for (size_t i = 0; i < test_case_size; ++i) {
       const test::TestCaseRecord& test_case = test_cases[i];
       FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
@@ skipping 46 matching lines @@
         }
         test_case_map.erase(relative);
       }
     }
     EXPECT_TRUE(test_case_map.empty());
   }
 
   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);
   }
 
  private:
   base::ScopedTempDir base_;
 
   const GURL origin_;
   const FileSystemType src_type_;
   const FileSystemType dest_type_;
 
@@ skipping 189 matching lines @@
                              test::kRegularTestCaseSize);
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 }  // namespace fileapi