Pepper: Use an adaptor to invoke FileSystemOperationRunner::OpenFile

content/browser/renderer_host/pepper/pepper_file_io_host.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 "content/browser/renderer_host/pepper/pepper_file_io_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/files/file_util_proxy.h"
@@ skipping 60 matching lines @@
   if (!host)
     return false;
   return client->IsPluginAllowedToCallRequestOSFileHandle(
       host->GetBrowserContext(), document_url);
 }
 
 bool FileOpenForWrite(int32_t open_flags) {
   return (open_flags & (PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_APPEND)) != 0;
 }
 
+void FileCloser(base::File auto_close) {
+}
+
+void DidCloseFile(const base::Closure& on_close_callback) {
+  if (!on_close_callback.is_null())
+    on_close_callback.Run();
+}
+
+void DidOpenFile(base::WeakPtr<PepperFileIOHost> file_host,
+                 fileapi::FileSystemOperation::OpenFileCallback callback,
+                 base::File file,
+                 const base::Closure& on_close_callback) {
+  if (file_host) {
+    callback.Run(file.Pass(), on_close_callback);
+  } else {
+    BrowserThread::PostTaskAndReply(
+        BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&FileCloser, base::Passed(&file)),
+        base::Bind(&DidCloseFile, on_close_callback));
+  }
+}
+
 }  // namespace
 
 PepperFileIOHost::PepperFileIOHost(BrowserPpapiHostImpl* host,
                                    PP_Instance instance,
                                    PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       browser_ppapi_host_(host),
       render_process_host_(NULL),
       file_(BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)),
       open_flags_(0),
       file_system_type_(PP_FILESYSTEMTYPE_INVALID),
       max_written_offset_(0),
-      check_quota_(false),
-      weak_factory_(this) {
+      check_quota_(false) {
   int unused;
   if (!host->GetRenderFrameIDsForInstance(
           instance, &render_process_id_, &unused)) {
     render_process_id_ = -1;
   }
 }
 
 PepperFileIOHost::~PepperFileIOHost() {}
 
 int32_t PepperFileIOHost::OnResourceMessageReceived(
@@ skipping 72 matching lines @@
       }
     }
     if (!CanOpenFileSystemURLWithPepperFlags(
             open_flags, render_process_id_, file_system_url_))
       return PP_ERROR_NOACCESS;
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&GetUIThreadStuffForInternalFileSystems, render_process_id_),
         base::Bind(&PepperFileIOHost::GotUIThreadStuffForInternalFileSystems,
-                   weak_factory_.GetWeakPtr(),
+                   AsWeakPtr(),
                    context->MakeReplyMessageContext(),
                    platform_file_flags));
   } else {
     base::FilePath path = file_ref_host->GetExternalFilePath();
     if (!CanOpenWithPepperFlags(open_flags, render_process_id_, path))
       return PP_ERROR_NOACCESS;
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&GetResolvedRenderProcessId, render_process_id_),
         base::Bind(&PepperFileIOHost::GotResolvedRenderProcessId,
-                   weak_factory_.GetWeakPtr(),
+                   AsWeakPtr(),
                    context->MakeReplyMessageContext(),
                    path,
                    platform_file_flags));
   }
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PepperFileIOHost::GotUIThreadStuffForInternalFileSystems(
     ppapi::host::ReplyMessageContext reply_context,
@@ skipping 10 matching lines @@
   }
 
   if (!file_system_context_->GetFileSystemBackend(file_system_url_.type())) {
     reply_context.params.set_result(PP_ERROR_FAILED);
     SendOpenErrorReply(reply_context);
     return;
   }
 
   DCHECK(file_system_host_.get());
   DCHECK(file_system_host_->GetFileSystemOperationRunner());
+
   file_system_host_->GetFileSystemOperationRunner()->OpenFile(
       file_system_url_,
       platform_file_flags,
-      base::Bind(&PepperFileIOHost::DidOpenInternalFile,
-                 weak_factory_.GetWeakPtr(),
-                 reply_context));
+      base::Bind(&DidOpenFile,
+                 AsWeakPtr(),
+                 base::Bind(&PepperFileIOHost::DidOpenInternalFile,
+                            AsWeakPtr(),
+                            reply_context)));
 }
 
 void PepperFileIOHost::DidOpenInternalFile(
     ppapi::host::ReplyMessageContext reply_context,
     base::File file,
     const base::Closure& on_close_callback) {
   if (file.IsValid()) {
     on_close_callback_ = on_close_callback;
 
     if (FileOpenForWrite(open_flags_) && file_system_host_->ChecksQuota()) {
       check_quota_ = true;
       file_system_host_->OpenQuotaFile(
           this,
           file_system_url_,
           base::Bind(&PepperFileIOHost::DidOpenQuotaFile,
-                     weak_factory_.GetWeakPtr(),
+                     AsWeakPtr(),
                      reply_context,
                      base::Passed(&file)));
       return;
     }
   }
 
   DCHECK(!file_.IsValid());
   base::File::Error error =
       file.IsValid() ? base::File::FILE_OK : file.error_details();
   file_.SetFile(file.Pass());
   OnOpenProxyCallback(reply_context, error);
 }
 
 void PepperFileIOHost::GotResolvedRenderProcessId(
     ppapi::host::ReplyMessageContext reply_context,
     base::FilePath path,
     int file_flags,
     base::ProcessId resolved_render_process_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   resolved_render_process_id_ = resolved_render_process_id;
   file_.CreateOrOpen(
       path,
       file_flags,
       base::Bind(&PepperFileIOHost::OnOpenProxyCallback,
-                 weak_factory_.GetWeakPtr(),
+                 AsWeakPtr(),
                  reply_context));
 }
 
 int32_t PepperFileIOHost::OnHostMsgTouch(
     ppapi::host::HostMessageContext* context,
     PP_Time last_access_time,
     PP_Time last_modified_time) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
 
   if (!file_.SetTimes(
           PPTimeToTime(last_access_time),
           PPTimeToTime(last_modified_time),
           base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback,
-                     weak_factory_.GetWeakPtr(),
+                     AsWeakPtr(),
                      context->MakeReplyMessageContext()))) {
     return PP_ERROR_FAILED;
   }
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperFileIOHost::OnHostMsgSetLength(
     ppapi::host::HostMessageContext* context,
     int64_t length) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
   if (length < 0)
     return PP_ERROR_BADARGUMENT;
 
   // Quota checks are performed on the plugin side, in order to use the same
   // quota reservation and request system as Write.
 
   if (!file_.SetLength(
           length,
           base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback,
-                     weak_factory_.GetWeakPtr(),
+                     AsWeakPtr(),
                      context->MakeReplyMessageContext()))) {
     return PP_ERROR_FAILED;
   }
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperFileIOHost::OnHostMsgFlush(
     ppapi::host::HostMessageContext* context) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
 
   if (!file_.Flush(
           base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback,
-                     weak_factory_.GetWeakPtr(),
+                     AsWeakPtr(),
                      context->MakeReplyMessageContext()))) {
     return PP_ERROR_FAILED;
   }
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperFileIOHost::OnHostMsgClose(
     ppapi::host::HostMessageContext* context,
     const ppapi::FileGrowth& file_growth) {
   if (check_quota_) {
     file_system_host_->CloseQuotaFile(this, file_growth);
     check_quota_ = false;
   }
 
   if (file_.IsValid()) {
     file_.Close(base::Bind(&PepperFileIOHost::DidCloseFile,
-                           weak_factory_.GetWeakPtr()));
+                           AsWeakPtr()));
   }
   return PP_OK;
 }
 
 void PepperFileIOHost::DidOpenQuotaFile(
     ppapi::host::ReplyMessageContext reply_context,
     base::File file,
     int64_t max_written_offset) {
   DCHECK(!file_.IsValid());
   DCHECK(file.IsValid());
@@ skipping 18 matching lines @@
 
   GURL document_url =
       browser_ppapi_host_->GetDocumentURLForInstance(pp_instance());
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GetPluginAllowedToCallRequestOSFileHandle,
                  render_process_id_,
                  document_url),
       base::Bind(&PepperFileIOHost::GotPluginAllowedToCallRequestOSFileHandle,
-                 weak_factory_.GetWeakPtr(),
+                 AsWeakPtr(),
                  context->MakeReplyMessageContext()));
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PepperFileIOHost::GotPluginAllowedToCallRequestOSFileHandle(
     ppapi::host::ReplyMessageContext reply_context,
     bool plugin_allowed) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!browser_ppapi_host_->external_plugin() ||
       host()->permissions().HasPermission(ppapi::PERMISSION_PRIVATE) ||
@@ skipping 58 matching lines @@
 
   ppapi::proxy::SerializedHandle file_handle;
   // A non-zero resource id signals NaClIPCAdapter to create a NaClQuotaDesc.
   PP_Resource quota_file_io = check_quota_ ? pp_resource() : 0;
   file_handle.set_file_handle(transit_file, open_flags, quota_file_io);
   reply_context->params.AppendHandle(file_handle);
   return true;
 }
 
 }  // namespace content