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

webkit/browser/fileapi/copy_or_move_file_validator_unittest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 80 matching lines @@
     TestMountPointProvider* provider = static_cast<TestMountPointProvider*>(
         file_system_context_->GetMountPointProvider(kWithValidatorType));
     provider->InitializeCopyOrMoveFileValidatorFactory(factory.Pass());
   }
 
   void CopyTest(base::PlatformFileError expected) {
     ASSERT_TRUE(FileExists(copy_src_, 10));
     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)
       EXPECT_TRUE(FileExists(copy_dest_, 10));
     else
       EXPECT_FALSE(FileExists(copy_dest_, 10));
   };
 
   void MoveTest(base::PlatformFileError expected) {
     ASSERT_TRUE(FileExists(move_src_, 10));
     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));
       EXPECT_TRUE(FileExists(move_dest_, 10));
     } else {
       EXPECT_TRUE(FileExists(move_src_, 10));
       EXPECT_FALSE(FileExists(move_dest_, 10));
     }
   };
 
  private:
   FileSystemURL SourceURL(const std::string& path) {
     return file_system_context_->CreateCrackedFileSystemURL(
         origin_, src_type_,
         base::FilePath().AppendASCII("src").AppendASCII(path));
   }
 
   FileSystemURL DestURL(const std::string& path) {
     return file_system_context_->CreateCrackedFileSystemURL(
         origin_, dest_type_,
         base::FilePath().AppendASCII("dest").AppendASCII(path));
   }
 
   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_;
 
   const GURL origin_;
 
   const FileSystemType src_type_;
   const FileSystemType dest_type_;
   std::string src_fsid_;
   std::string dest_fsid_;
@@ skipping 112 matching lines @@
 
   scoped_ptr<CopyOrMoveFileValidatorFactory> accept_factory(
       new TestCopyOrMoveFileValidatorFactory(true /*accept_all*/));
   helper.SetMediaCopyOrMoveFileValidatorFactory(accept_factory.Pass());
 
   helper.CopyTest(base::PLATFORM_FILE_ERROR_SECURITY);
   helper.MoveTest(base::PLATFORM_FILE_ERROR_SECURITY);
 }
 
 }  // namespace fileapi