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

webkit/plugins/ppapi/ppb_file_ref_impl.cc

 // Copyright (c) 2012 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 "webkit/plugins/ppapi/ppb_file_ref_impl.h"
 
 #include "base/files/file_util_proxy.h"
 #include "base/platform_file.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 105 matching lines @@
 }
 
 void GetFileInfoCallback(
     scoped_refptr<base::TaskRunner> task_runner,
     base::PlatformFile file,
     linked_ptr<PP_FileInfo> info,
     scoped_refptr<TrackedCallback> callback,
     base::PlatformFileError error_code,
     const base::PlatformFileInfo& file_info) {
   base::FileUtilProxy::Close(
-      task_runner, file, base::Bind(&IgnoreCloseCallback));
+      task_runner.get(), file, base::Bind(&IgnoreCloseCallback));
 
   if (!TrackedCallback::IsPending(callback))
     return;
 
   int32_t pp_error = ::ppapi::PlatformFileErrorToPepperError(error_code);
   if (pp_error != PP_OK) {
     callback->Run(pp_error);
     return;
   }
 
@@ skipping 12 matching lines @@
     return;
 
   int32_t pp_error = ::ppapi::PlatformFileErrorToPepperError(error_code);
   if (pp_error != PP_OK) {
     callback->Run(pp_error);
     return;
   }
   base::PlatformFile file = passed_file.ReleaseValue();
 
   if (!base::FileUtilProxy::GetFileInfoFromPlatformFile(
-          task_runner, file,
-          base::Bind(&GetFileInfoCallback, task_runner, file, info,
-                     callback))) {
+          task_runner.get(),
+          file,
+          base::Bind(
+              &GetFileInfoCallback, task_runner, file, info, callback))) {
     base::FileUtilProxy::Close(
-        task_runner, file, base::Bind(&IgnoreCloseCallback));
+        task_runner.get(), file, base::Bind(&IgnoreCloseCallback));
     callback->Run(PP_ERROR_FAILED);
   }
 }
 
 void DidReadMetadata(
     scoped_refptr< ::ppapi::TrackedCallback> callback,
     linked_ptr<PP_FileInfo> info,
     PP_FileSystemType file_system_type,
     const base::PlatformFileInfo& file_info,
     const base::FilePath& unused) {
@@ skipping 132 matching lines @@
   size_t pos = virtual_path.rfind('/');
   CHECK(pos != std::string::npos);
 
   // If the path is "/foo", then we want to include the slash.
   if (pos == 0)
     pos++;
   std::string parent_path = virtual_path.substr(0, pos);
 
   scoped_refptr<PPB_FileRef_Impl> parent_ref(
       CreateInternal(pp_instance(), file_system_, parent_path));
-  if (!parent_ref)
+  if (!parent_ref.get())
     return 0;
   return parent_ref->GetReference();
 }
 
 int32_t PPB_FileRef_Impl::MakeDirectory(
     PP_Bool make_ancestors,
     scoped_refptr<TrackedCallback> callback) {
   if (!IsValidNonExternalFileSystem())
     return PP_ERROR_NOACCESS;
 
@@ skipping 59 matching lines @@
   if (!plugin_instance->delegate()->Rename(
           GetFileSystemURL(), new_file_ref->GetFileSystemURL(),
           base::Bind(&DidFinishFileOperation, callback)))
     return PP_ERROR_FAILED;
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Var PPB_FileRef_Impl::GetAbsolutePath() {
   if (GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL)
     return GetPath();
-  if (!external_path_var_) {
-    external_path_var_ = new StringVar(
-        external_file_system_path_.AsUTF8Unsafe());
+  if (!external_path_var_.get()) {
+    external_path_var_ =
+        new StringVar(external_file_system_path_.AsUTF8Unsafe());
   }
   return external_path_var_->GetPPVar();
 }
 
 base::FilePath PPB_FileRef_Impl::GetSystemPath() const {
   if (GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL) {
     NOTREACHED();
     return base::FilePath();
   }
   return external_file_system_path_;
@@ skipping 45 matching lines @@
                                 scoped_refptr<TrackedCallback> callback) {
   NOTREACHED();
   return PP_ERROR_FAILED;
 }
 
 int32_t PPB_FileRef_Impl::QueryInHost(
     linked_ptr<PP_FileInfo> info,
     scoped_refptr<TrackedCallback> callback) {
   scoped_refptr<PluginInstance> plugin_instance =
       ResourceHelper::GetPluginInstance(this);
-  if (!plugin_instance)
+  if (!plugin_instance.get())
     return PP_ERROR_FAILED;
 
   if (!file_system_) {
     // External file system
     // We have to do something totally different for external file systems.
 
     // TODO(teravest): Use the SequencedWorkerPool instead.
     scoped_refptr<base::TaskRunner> task_runner =
         plugin_instance->delegate()->GetFileThreadMessageLoopProxy();
     if (!plugin_instance->delegate()->AsyncOpenFile(
@@ skipping 48 matching lines @@
           GetFileSystemURL(),
           base::Bind(&DidReadDirectory,
                      callback, base::Unretained(this), files, file_types),
           base::Bind(&DidFinishFileOperation, callback)))
     return PP_ERROR_FAILED;
   return PP_OK_COMPLETIONPENDING;
 }
 
 }  // namespace ppapi
 }  // namespace webkit