Remove PluginDelegate completely. In a followup I'll rename PepperPluginDelegateImpl to something c…

content/renderer/pepper/pepper_file_io_host.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 "content/renderer/pepper/pepper_file_io_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_util_proxy.h"
 #include "content/child/child_thread.h"
 #include "content/child/fileapi/file_system_dispatcher.h"
 #include "content/child/quota_dispatcher.h"
 #include "content/common/fileapi/file_system_messages.h"
 #include "content/public/common/content_client.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/pepper/host_globals.h"
+#include "content/renderer/pepper/pepper_plugin_delegate_impl.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/ppb_file_ref_impl.h"
 #include "content/renderer/pepper/quota_file_io.h"
+#include "content/renderer/pepper/resource_helper.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/file_type_conversion.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/thunk/enter.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 
@@ skipping 102 matching lines @@
                quota::kQuotaLimitTypeUnknown,
                PepperFileIOHost::NotifyCloseFileCallback());
 }
 
 }  // namespace
 
 PepperFileIOHost::PepperFileIOHost(RendererPpapiHost* host,
                                    PP_Instance instance,
                                    PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
-      plugin_delegate_(NULL),
       file_(base::kInvalidPlatformFileValue),
       file_system_type_(PP_FILESYSTEMTYPE_INVALID),
       quota_policy_(quota::kQuotaLimitTypeUnknown),
       is_running_in_process_(host->IsRunningInProcess()),
       open_flags_(0),
       weak_factory_(this) {
-  // TODO(victorhsieh): eliminate plugin_delegate_ as it's no longer needed.
-  PepperPluginInstanceImpl* plugin_instance =
-      HostGlobals::Get()->GetInstance(instance);
-  plugin_delegate_ = plugin_instance ? plugin_instance->delegate() : NULL;
 }
 
 PepperFileIOHost::~PepperFileIOHost() {
   OnHostMsgClose(NULL);
 }
 
 int32_t PepperFileIOHost::OnResourceMessageReceived(
     const IPC::Message& msg,
     ppapi::host::HostMessageContext* context) {
   IPC_BEGIN_MESSAGE_MAP(PepperFileIOHost, msg)
@@ skipping 45 matching lines @@
 
   PPB_FileRef_API* file_ref_api = enter.object();
   PP_FileSystemType type = file_ref_api->GetFileSystemType();
   if (type != PP_FILESYSTEMTYPE_LOCALPERSISTENT &&
       type != PP_FILESYSTEMTYPE_LOCALTEMPORARY &&
       type != PP_FILESYSTEMTYPE_EXTERNAL &&
       type != PP_FILESYSTEMTYPE_ISOLATED)
     return PP_ERROR_FAILED;
   file_system_type_ = type;
 
-  if (!plugin_delegate_)
-    return PP_ERROR_FAILED;
-
   PPB_FileRef_Impl* file_ref = static_cast<PPB_FileRef_Impl*>(file_ref_api);
   if (file_ref->HasValidFileSystem()) {
     file_system_url_ = file_ref->GetFileSystemURL();
 
     FileSystemDispatcher* file_system_dispatcher =
         ChildThread::current()->file_system_dispatcher();
     AsyncOpenFileSystemURLCallback callback = base::Bind(
         &PepperFileIOHost::ExecutePlatformOpenFileSystemURLCallback,
         weak_factory_.GetWeakPtr(),
         context->MakeReplyMessageContext());
     file_system_dispatcher->OpenFile(
       file_system_url_, flags,
       base::Bind(&DidOpenFileSystemURL, callback),
       base::Bind(&DidFailOpenFileSystemURL, callback));
   } else {
-    if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL)
+    PepperPluginDelegateImpl* plugin_delegate =
+        static_cast<PepperPluginInstanceImpl*>(
+            PepperPluginInstance::Get(pp_instance()))->delegate();
+    if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL || !plugin_delegate)
       return PP_ERROR_FAILED;
-    if (!plugin_delegate_->AsyncOpenFile(
+    if (!plugin_delegate->AsyncOpenFile(
             file_ref->GetSystemPath(), flags,
             base::Bind(&PepperFileIOHost::ExecutePlatformOpenFileCallback,
                        weak_factory_.GetWeakPtr(),
                        context->MakeReplyMessageContext())))
       return PP_ERROR_FAILED;
   }
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperFileIOHost::OnHostMsgQuery(
     ppapi::host::HostMessageContext* context) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
 
-  if (!plugin_delegate_)
-    return PP_ERROR_FAILED;
-
   if (!base::FileUtilProxy::GetFileInfoFromPlatformFile(
-          plugin_delegate_->GetFileThreadMessageLoopProxy().get(),
+          RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(),
           file_,
           base::Bind(&PepperFileIOHost::ExecutePlatformQueryCallback,
                      weak_factory_.GetWeakPtr(),
                      context->MakeReplyMessageContext())))
     return PP_ERROR_FAILED;
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 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 (!plugin_delegate_)
-    return PP_ERROR_FAILED;
-
   if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL) {
     FileSystemDispatcher* file_system_dispatcher =
         ChildThread::current()->file_system_dispatcher();
     file_system_dispatcher->TouchFile(
         file_system_url_,
         PPTimeToTime(last_access_time),
         PPTimeToTime(last_modified_time),
         base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback,
                     weak_factory_.GetWeakPtr(),
                     context->MakeReplyMessageContext()));
     state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
     return PP_OK_COMPLETIONPENDING;
   }
 
   // TODO(nhiroki): fix a failure of FileIO.Touch for an external filesystem on
   // Mac and Linux due to sandbox restrictions (http://crbug.com/101128).
   if (!base::FileUtilProxy::Touch(
-          plugin_delegate_->GetFileThreadMessageLoopProxy().get(),
+          RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(),
           file_,
           PPTimeToTime(last_access_time),
           PPTimeToTime(last_modified_time),
           base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback,
                      weak_factory_.GetWeakPtr(),
                      context->MakeReplyMessageContext())))
     return PP_ERROR_FAILED;
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
@@ skipping 11 matching lines @@
   // Validate max_read_length before allocating below. This value is coming from
   // the untrusted plugin.
   if (max_read_length < 0) {
     ReplyMessageContext reply_context = context->MakeReplyMessageContext();
     reply_context.params.set_result(PP_ERROR_FAILED);
     host()->SendReply(reply_context,
                       PpapiPluginMsg_FileIO_ReadReply(std::string()));
     return PP_OK_COMPLETIONPENDING;
   }
 
-  if (!plugin_delegate_)
-    return PP_ERROR_FAILED;
-
   if (!base::FileUtilProxy::Read(
-          plugin_delegate_->GetFileThreadMessageLoopProxy().get(),
+          RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(),
           file_,
           offset,
           max_read_length,
           base::Bind(&PepperFileIOHost::ExecutePlatformReadCallback,
                      weak_factory_.GetWeakPtr(),
                      context->MakeReplyMessageContext())))
     return PP_ERROR_FAILED;
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_READ);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperFileIOHost::OnHostMsgWrite(
     ppapi::host::HostMessageContext* context,
     int64_t offset,
     const std::string& buffer) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_WRITE, true);
   if (rv != PP_OK)
     return rv;
 
   if (quota_file_io_) {
     if (!quota_file_io_->Write(
             offset, buffer.c_str(), buffer.size(),
             base::Bind(&PepperFileIOHost::ExecutePlatformWriteCallback,
                        weak_factory_.GetWeakPtr(),
                        context->MakeReplyMessageContext())))
       return PP_ERROR_FAILED;
   } else {
-    if (!plugin_delegate_)
-      return PP_ERROR_FAILED;
-
     if (!base::FileUtilProxy::Write(
-            plugin_delegate_->GetFileThreadMessageLoopProxy().get(),
+            RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(),
             file_,
             offset,
             buffer.c_str(),
             buffer.size(),
             base::Bind(&PepperFileIOHost::ExecutePlatformWriteCallback,
                        weak_factory_.GetWeakPtr(),
                        context->MakeReplyMessageContext())))
       return PP_ERROR_FAILED;
   }
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_WRITE);
   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 (!plugin_delegate_)
-    return PP_ERROR_FAILED;
-
   if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL) {
     FileSystemDispatcher* file_system_dispatcher =
         ChildThread::current()->file_system_dispatcher();
     file_system_dispatcher->Truncate(
         file_system_url_, length, NULL,
         base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback,
                    weak_factory_.GetWeakPtr(),
                    context->MakeReplyMessageContext()));
   } else {
     // TODO(nhiroki): fix a failure of FileIO.SetLength for an external
     // filesystem on Mac due to sandbox restrictions (http://crbug.com/156077).
     if (!base::FileUtilProxy::Truncate(
-            plugin_delegate_->GetFileThreadMessageLoopProxy().get(),
+            RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(),
             file_,
             length,
             base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback,
                        weak_factory_.GetWeakPtr(),
                        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 (!plugin_delegate_)
-    return PP_ERROR_FAILED;
-
   if (!base::FileUtilProxy::Flush(
-          plugin_delegate_->GetFileThreadMessageLoopProxy().get(),
+          RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(),
           file_,
           base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback,
                      weak_factory_.GetWeakPtr(),
                      context->MakeReplyMessageContext())))
     return PP_ERROR_FAILED;
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperFileIOHost::OnHostMsgClose(
     ppapi::host::HostMessageContext* context) {
-  if (file_ != base::kInvalidPlatformFileValue && plugin_delegate_) {
+  if (file_ != base::kInvalidPlatformFileValue) {
     base::FileUtilProxy::Close(
-        plugin_delegate_->GetFileThreadMessageLoopProxy().get(),
+        RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(),
         file_,
         base::ResetAndReturn(&notify_close_file_callback_));
     file_ = base::kInvalidPlatformFileValue;
     quota_file_io_.reset();
   }
   return PP_OK;
 }
 
 int32_t PepperFileIOHost::OnHostMsgWillWrite(
     ppapi::host::HostMessageContext* context,
@@ skipping 169 matching lines @@
   // On the plugin side, the callback expects a parameter with different meaning
   // depends on whether is negative or not. It is the result here. We translate
   // for the callback.
   int32_t pp_error = ::ppapi::PlatformFileErrorToPepperError(error_code);
   reply_context.params.set_result(ErrorOrByteNumber(pp_error, bytes_written));
   host()->SendReply(reply_context, PpapiPluginMsg_FileIO_GeneralReply());
   state_manager_.SetOperationFinished();
 }
 
 }  // namespace content