Create a public API around webkit::ppapi::PluginInstance and use it in chrome. After this, webkit/p…

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/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/escape.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/file_type_conversion.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_file_system_api.h"
 #include "url/gurl.h"
 #include "webkit/common/fileapi/directory_entry.h"
 #include "webkit/common/fileapi/file_system_util.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/plugin_delegate.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
-#include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
+#include "webkit/plugins/ppapi/ppapi_plugin_instance_impl.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 
 using ppapi::HostResource;
 using ppapi::PPB_FileRef_CreateInfo;
 using ppapi::PPTimeToTime;
 using ppapi::StringVar;
 using ppapi::TrackedCallback;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_FileRef_API;
 using ppapi::thunk::PPB_FileSystem_API;
@@ skipping 190 matching lines @@
       external_file_system_path_(external_file_path) {
 }
 
 PPB_FileRef_Impl::~PPB_FileRef_Impl() {
 }
 
 // static
 PPB_FileRef_Impl* PPB_FileRef_Impl::CreateInternal(PP_Instance instance,
                                                    PP_Resource pp_file_system,
                                                    const std::string& path) {
-  PluginInstance* plugin_instance =
+  PluginInstanceImpl* plugin_instance =
       ResourceHelper::PPInstanceToPluginInstance(instance);
   if (!plugin_instance || !plugin_instance->delegate())
     return 0;
 
   PP_FileSystemType type =
       plugin_instance->delegate()->GetFileSystemType(instance, pp_file_system);
   if (type != PP_FILESYSTEMTYPE_LOCALPERSISTENT &&
       type != PP_FILESYSTEMTYPE_LOCALTEMPORARY &&
       type != PP_FILESYSTEMTYPE_EXTERNAL &&
       type != PP_FILESYSTEMTYPE_ISOLATED)
@@ skipping 56 matching lines @@
     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;
 
-  PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
+  PluginInstanceImpl* plugin_instance = ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
   plugin_instance->delegate()->MakeDirectory(
       GetFileSystemURL(), PP_ToBool(make_ancestors),
       base::Bind(&DidFinishFileOperation, callback));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileRef_Impl::Touch(PP_Time last_access_time,
                                 PP_Time last_modified_time,
                                 scoped_refptr<TrackedCallback> callback) {
   if (!IsValidNonExternalFileSystem())
     return PP_ERROR_NOACCESS;
 
-  PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
+  PluginInstanceImpl* plugin_instance = ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
   plugin_instance->delegate()->Touch(
       GetFileSystemURL(),
       PPTimeToTime(last_access_time),
       PPTimeToTime(last_modified_time),
       base::Bind(&DidFinishFileOperation, callback));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileRef_Impl::Delete(scoped_refptr<TrackedCallback> callback) {
   if (!IsValidNonExternalFileSystem())
     return PP_ERROR_NOACCESS;
 
-  PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
+  PluginInstanceImpl* plugin_instance = ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
   plugin_instance->delegate()->Delete(
       GetFileSystemURL(),
       base::Bind(&DidFinishFileOperation, callback));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileRef_Impl::Rename(PP_Resource new_pp_file_ref,
                                  scoped_refptr<TrackedCallback> callback) {
   EnterResourceNoLock<PPB_FileRef_API> enter(new_pp_file_ref, true);
   if (enter.failed())
     return PP_ERROR_BADRESOURCE;
   PPB_FileRef_Impl* new_file_ref =
       static_cast<PPB_FileRef_Impl*>(enter.object());
 
   if (!IsValidNonExternalFileSystem() ||
       file_system_ != new_file_ref->file_system_)
     return PP_ERROR_NOACCESS;
 
   // TODO(viettrungluu): Also cancel when the new file ref is destroyed?
   // http://crbug.com/67624
-  PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
+  PluginInstanceImpl* plugin_instance = ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
   plugin_instance->delegate()->Rename(
       GetFileSystemURL(), new_file_ref->GetFileSystemURL(),
       base::Bind(&DidFinishFileOperation, callback));
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Var PPB_FileRef_Impl::GetAbsolutePath() {
   if (GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL)
@@ skipping 22 matching lines @@
     return GURL();
   }
 
   const std::string& virtual_path = GetCreateInfo().path;
   CHECK(!virtual_path.empty());  // Should always be at least "/".
 
   // Since |virtual_path_| starts with a '/', it looks like an absolute path.
   // We need to trim off the '/' before calling Resolve, as FileSystem URLs
   // start with a storage type identifier that looks like a path segment.
 
-  PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
+  PluginInstanceImpl* plugin_instance = ResourceHelper::GetPluginInstance(this);
   PluginDelegate* delegate =
       plugin_instance ? plugin_instance->delegate() : NULL;
   if (!delegate)
     return GURL();
   return GURL(delegate->GetFileSystemRootUrl(pp_instance(), file_system_))
       .Resolve(net::EscapePath(virtual_path.substr(1)));
 }
 
 bool PPB_FileRef_Impl::IsValidNonExternalFileSystem() const {
-  PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
+  PluginInstanceImpl* plugin_instance = ResourceHelper::GetPluginInstance(this);
   PluginDelegate* delegate =
       plugin_instance ? plugin_instance->delegate() : NULL;
   return delegate &&
       delegate->IsFileSystemOpened(pp_instance(), file_system_) &&
       delegate->GetFileSystemType(pp_instance(), file_system_) !=
           PP_FILESYSTEMTYPE_EXTERNAL;
 }
 
 bool PPB_FileRef_Impl::HasValidFileSystem() const {
-  PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
+  PluginInstanceImpl* plugin_instance = ResourceHelper::GetPluginInstance(this);
   PluginDelegate* delegate =
       plugin_instance ? plugin_instance->delegate() : NULL;
   return delegate && delegate->IsFileSystemOpened(pp_instance(), file_system_);
 }
 
 int32_t PPB_FileRef_Impl::Query(PP_FileInfo* info,
                                 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 =
+  scoped_refptr<PluginInstanceImpl> plugin_instance =
       ResourceHelper::GetPluginInstance(this);
   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(
             GetSystemPath(),
             base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ,
             base::Bind(&QueryCallback, task_runner, info, callback)))
       return PP_ERROR_FAILED;
   } else {
     // Non-external file system
     if (!HasValidFileSystem())
       return PP_ERROR_NOACCESS;
 
-    PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
+    PluginInstanceImpl* plugin_instance =
+        ResourceHelper::GetPluginInstance(this);
     PluginDelegate* delegate =
         plugin_instance ? plugin_instance->delegate() : NULL;
     if (!delegate)
       return PP_ERROR_FAILED;
 
     PP_FileSystemType file_system_type =
         delegate->GetFileSystemType(pp_instance(), file_system_);
     plugin_instance->delegate()->Query(
         GetFileSystemURL(),
         base::Bind(&DidReadMetadata, callback, info, file_system_type),
         base::Bind(&DidFinishFileOperation, callback));
   }
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileRef_Impl::ReadDirectoryEntries(
     const PP_ArrayOutput& output,
     scoped_refptr<TrackedCallback> callback) {
   NOTREACHED();
   return PP_ERROR_FAILED;
 }
 
 int32_t PPB_FileRef_Impl::ReadDirectoryEntriesInHost(
     linked_ptr<std::vector< ::ppapi::PPB_FileRef_CreateInfo> > files,
     linked_ptr<std::vector<PP_FileType> > file_types,
     scoped_refptr<TrackedCallback> callback) {
   if (!IsValidNonExternalFileSystem())
     return PP_ERROR_NOACCESS;
 
-  PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
+  PluginInstanceImpl* plugin_instance = ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
 
   // TODO(yzshen): Passing base::Unretained(this) to the callback could
   // be dangerous.
   plugin_instance->delegate()->ReadDirectoryEntries(
       GetFileSystemURL(),
       base::Bind(&DidReadDirectory,
                  callback, base::Unretained(this), files, file_types),
       base::Bind(&DidFinishFileOperation, callback));
   return PP_OK_COMPLETIONPENDING;
 }
 
 }  // namespace ppapi
 }  // namespace webkit