Open pepper files directly in browser.

ppapi/proxy/ppb_flash_proxy.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 "ppapi/proxy/ppb_flash_proxy.h"
 
 #include <map>
 #include <set>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/time.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/c/private/ppb_flash_print.h"
 #include "ppapi/proxy/host_dispatcher.h"
+#include "ppapi/proxy/pepper_file_messages.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/proxy_module.h"
 #include "ppapi/proxy/serialized_var.h"
+#include "ppapi/shared_impl/dir_contents.h"
+#include "ppapi/shared_impl/file_type_conversion.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/resource_tracker.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_instance_api.h"
 #include "ppapi/thunk/ppb_url_request_info_api.h"
@@ skipping 381 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_FlashSetFullscreen,
                         OnHostMsgFlashSetFullscreen)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_FlashGetScreenSize,
                         OnHostMsgFlashGetScreenSize)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_IsClipboardFormatAvailable,
                         OnHostMsgIsClipboardFormatAvailable)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_ReadClipboardData,
                         OnHostMsgReadClipboardData)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_WriteClipboardData,
                         OnHostMsgWriteClipboardData)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_OpenFile,
-                        OnHostMsgOpenFile)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_RenameFile,
-                        OnHostMsgRenameFile)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_DeleteFileOrDir,
-                        OnHostMsgDeleteFileOrDir)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_CreateDir,
-                        OnHostMsgCreateDir)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_QueryFile,
-                        OnHostMsgQueryFile)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_GetDirContents,
-                        OnHostMsgGetDirContents)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_OpenFileRef,
                         OnHostMsgOpenFileRef)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_QueryFileRef,
                         OnHostMsgQueryFileRef)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_GetDeviceID,
                         OnHostMsgGetDeviceID)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_InvokePrinting,
                         OnHostMsgInvokePrinting)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 210 matching lines @@
       instance,
       static_cast<int>(clipboard_type),
       formats_vector,
       data_items_vector));
   // Assume success, since it allows us to avoid a sync IPC.
   return PP_OK;
 }
 
 bool PPB_Flash_Proxy::CreateThreadAdapterForInstance(PP_Instance instance) {
   if (!g_module_local_thread_adapter) {
     g_module_local_thread_adapter = new ModuleLocalThreadAdapter();

[yzshen1, 2012/06/06 16:56:37]

The code no longer uses this. You could make this and
ClearThreadAdapterForInstance no-ops. And remove the definition of
ModuleLocalThreadAdapter.

     g_module_local_thread_adapter->AddRef();  // Leaked, this object is global.
   }
 
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return false;
   }
   g_module_local_thread_adapter->AddInstanceRouting(instance, dispatcher);
   return true;
 }
 
 void PPB_Flash_Proxy::ClearThreadAdapterForInstance(PP_Instance instance) {
   if (g_module_local_thread_adapter)
     g_module_local_thread_adapter->ClearInstanceRouting(instance);
 }
 
-int32_t PPB_Flash_Proxy::OpenFile(PP_Instance instance,
+int32_t PPB_Flash_Proxy::OpenFile(PP_Instance,
                                   const char* path,
                                   int32_t mode,
                                   PP_FileHandle* file) {
-  if (!g_module_local_thread_adapter)
-    return PP_ERROR_FAILED;
+  int flags = 0;
+  if (!path ||
+      !ppapi::PepperFileOpenFlagsToPlatformFileFlags(mode, &flags) ||
+      !file)
+    return PP_ERROR_BADARGUMENT;
 
-  int32_t result = PP_ERROR_FAILED;
-  IPC::PlatformFileForTransit transit;
-  g_module_local_thread_adapter->Send(instance,
-      new PpapiHostMsg_PPBFlash_OpenFile(
-          API_ID_PPB_FLASH, instance, path, mode, &transit, &result));
-  *file = IPC::PlatformFileForTransitToPlatformFile(transit);
-  return result;
+  base::PlatformFileError error;
+  IPC::PlatformFileForTransit transit_file;
+  ppapi::PepperFilePath pepper_path(ppapi::PepperFilePath::DOMAIN_MODULE_LOCAL,
+                                    FilePath::FromUTF8Unsafe(path));
+
+  if (PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(

[yzshen1, 2012/06/06 16:56:37]

I don't think it is safe to do so. OpenFile and other methods could be called
from non-main thread.

SendToBrowser() calls into ChildThread::Send() and it is not intended to be used
by multiple threads.

Have I missed anything?

+          new PepperFileMsg_OpenFile(pepper_path, flags,
+                                     &error, &transit_file))) {
+    *file = IPC::PlatformFileForTransitToPlatformFile(transit_file);
+  } else {
+    *file = base::kInvalidPlatformFileValue;
+    error = base::PLATFORM_FILE_ERROR_FAILED;
+  }
+
+  return ppapi::PlatformFileErrorToPepperError(error);
 }
 
-int32_t PPB_Flash_Proxy::RenameFile(PP_Instance instance,
-                                    const char* path_from,
-                                    const char* path_to) {
-  if (!g_module_local_thread_adapter)
-    return PP_ERROR_FAILED;
+int32_t PPB_Flash_Proxy::RenameFile(PP_Instance,
+                                    const char* from_path,
+                                    const char* to_path) {
+  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  ppapi::PepperFilePath pepper_from(ppapi::PepperFilePath::DOMAIN_MODULE_LOCAL,
+                                    FilePath::FromUTF8Unsafe(from_path));
+  ppapi::PepperFilePath pepper_to(ppapi::PepperFilePath::DOMAIN_MODULE_LOCAL,
+                                  FilePath::FromUTF8Unsafe(to_path));
 
-  int32_t result = PP_ERROR_FAILED;
-  g_module_local_thread_adapter->Send(instance,
-      new PpapiHostMsg_PPBFlash_RenameFile(
-          API_ID_PPB_FLASH, instance, path_from, path_to, &result));
-  return result;
+  PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
+      new PepperFileMsg_RenameFile(pepper_from, pepper_to, &error));
+
+  return ppapi::PlatformFileErrorToPepperError(error);
 }
 
-int32_t PPB_Flash_Proxy::DeleteFileOrDir(PP_Instance instance,
+int32_t PPB_Flash_Proxy::DeleteFileOrDir(PP_Instance,
                                          const char* path,
                                          PP_Bool recursive) {
-  if (!g_module_local_thread_adapter)
-    return PP_ERROR_FAILED;
+  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  ppapi::PepperFilePath pepper_path(ppapi::PepperFilePath::DOMAIN_MODULE_LOCAL,
+                                    FilePath::FromUTF8Unsafe(path));
 
-  int32_t result = PP_ERROR_FAILED;
-  g_module_local_thread_adapter->Send(instance,
-      new PpapiHostMsg_PPBFlash_DeleteFileOrDir(
-          API_ID_PPB_FLASH, instance, path, recursive, &result));
-  return result;
+  PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
+      new PepperFileMsg_DeleteFileOrDir(pepper_path,
+                                        PP_ToBool(recursive),
+                                        &error));
+
+  return ppapi::PlatformFileErrorToPepperError(error);
 }
 
-int32_t PPB_Flash_Proxy::CreateDir(PP_Instance instance, const char* path) {
-  if (!g_module_local_thread_adapter)
-    return PP_ERROR_FAILED;
+int32_t PPB_Flash_Proxy::CreateDir(PP_Instance, const char* path) {
+  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  ppapi::PepperFilePath pepper_path(ppapi::PepperFilePath::DOMAIN_MODULE_LOCAL,
+                                    FilePath::FromUTF8Unsafe(path));
 
-  int32_t result = PP_ERROR_FAILED;
-  g_module_local_thread_adapter->Send(instance,
-      new PpapiHostMsg_PPBFlash_CreateDir(
-          API_ID_PPB_FLASH, instance, path, &result));
-  return result;
+  PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
+      new PepperFileMsg_CreateDir(pepper_path, &error));
+
+  return ppapi::PlatformFileErrorToPepperError(error);
 }
 
-int32_t PPB_Flash_Proxy::QueryFile(PP_Instance instance,
+int32_t PPB_Flash_Proxy::QueryFile(PP_Instance,
                                    const char* path,
                                    PP_FileInfo* info) {
-  if (!g_module_local_thread_adapter)
-    return PP_ERROR_FAILED;
+  base::PlatformFileInfo file_info;
+  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  ppapi::PepperFilePath pepper_path(ppapi::PepperFilePath::DOMAIN_MODULE_LOCAL,
+                                    FilePath::FromUTF8Unsafe(path));
 
-  int32_t result = PP_ERROR_FAILED;
-  g_module_local_thread_adapter->Send(instance,
-      new PpapiHostMsg_PPBFlash_QueryFile(
-          API_ID_PPB_FLASH, instance, path, info, &result));
-  return result;
+  PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
+      new PepperFileMsg_QueryFile(pepper_path, &file_info, &error));
+
+  if (error == base::PLATFORM_FILE_OK) {
+    info->size = file_info.size;
+    info->creation_time = TimeToPPTime(file_info.creation_time);
+    info->last_access_time = TimeToPPTime(file_info.last_accessed);
+    info->last_modified_time = TimeToPPTime(file_info.last_modified);
+    info->system_type = PP_FILESYSTEMTYPE_EXTERNAL;
+    if (file_info.is_directory)
+        info->type = PP_FILETYPE_DIRECTORY;
+    else
+      info->type = PP_FILETYPE_REGULAR;
+  }
+
+  return ppapi::PlatformFileErrorToPepperError(error);
 }
 
-int32_t PPB_Flash_Proxy::GetDirContents(PP_Instance instance,
+int32_t PPB_Flash_Proxy::GetDirContents(PP_Instance,
                                         const char* path,
                                         PP_DirContents_Dev** contents) {
-  if (!g_module_local_thread_adapter)
-    return PP_ERROR_FAILED;
+  ppapi::DirContents entries;
+  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  ppapi::PepperFilePath pepper_path(ppapi::PepperFilePath::DOMAIN_MODULE_LOCAL,
+                                    FilePath::FromUTF8Unsafe(path));
 
-  int32_t result = PP_ERROR_FAILED;
-  std::vector<SerializedDirEntry> entries;
-  g_module_local_thread_adapter->Send(instance,
-      new PpapiHostMsg_PPBFlash_GetDirContents(
-          API_ID_PPB_FLASH, instance, path, &entries, &result));
+  PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
+      new PepperFileMsg_GetDirContents(pepper_path, &entries, &error));
 
-  if (result != PP_OK)
-    return result;
-
-  // Copy the serialized dir entries to the output struct.
-  *contents = new PP_DirContents_Dev;
-  (*contents)->count = static_cast<int32_t>(entries.size());
-  (*contents)->entries = new PP_DirEntry_Dev[entries.size()];
-  for (size_t i = 0; i < entries.size(); i++) {
-    const SerializedDirEntry& source = entries[i];
-    PP_DirEntry_Dev* dest = &(*contents)->entries[i];
-
-    char* name_copy = new char[source.name.size() + 1];
-    memcpy(name_copy, source.name.c_str(), source.name.size() + 1);
-    dest->name = name_copy;
-    dest->is_dir = PP_FromBool(source.is_dir);
+  if (error == base::PLATFORM_FILE_OK) {
+    // Copy the serialized dir entries to the output struct.
+    *contents = new PP_DirContents_Dev;
+    (*contents)->count = static_cast<int32_t>(entries.size());
+    (*contents)->entries = new PP_DirEntry_Dev[entries.size()];
+    for (size_t i = 0; i < entries.size(); i++) {
+      const ppapi::DirEntry& source = entries[i];
+      PP_DirEntry_Dev* dest = &(*contents)->entries[i];
+      std::string name = source.name.AsUTF8Unsafe();
+      char* name_copy = new char[name.size() + 1];
+      memcpy(name_copy, name.c_str(), name.size() + 1);
+      dest->name = name_copy;
+      dest->is_dir = PP_FromBool(source.is_dir);
+    }
   }
 
-  return result;
+  return ppapi::PlatformFileErrorToPepperError(error);
 }
 
 int32_t PPB_Flash_Proxy::OpenFileRef(PP_Instance instance,
                                      PP_Resource file_ref_id,
                                      int32_t mode,
                                      PP_FileHandle* file) {
   EnterResourceNoLock<thunk::PPB_FileRef_API> enter(file_ref_id, true);
   if (enter.failed())
     return PP_ERROR_BADRESOURCE;
 
@@ skipping 245 matching lines @@
         static_cast<PP_Flash_Clipboard_Type>(clipboard_type),
         data_item_count,
         formats_array.get(),
         data_items_array);
     DLOG_IF(WARNING, result != PP_OK)
         << "Write to clipboard failed unexpectedly.";
     (void)result;  // Prevent warning in release mode.
   }
 }
 
-void PPB_Flash_Proxy::OnHostMsgOpenFile(
-    PP_Instance instance,
-    const std::string& path,
-    int32_t mode,
-    IPC::PlatformFileForTransit* file_handle,
-    int32_t* result) {
-  EnterInstanceNoLock enter(instance);
-  if (enter.succeeded()) {
-    base::PlatformFile file;
-    *result = enter.functions()->GetFlashAPI()->OpenFile(
-        instance, path.c_str(), mode, &file);
-    *file_handle = PlatformFileToPlatformFileForTransit(
-        dispatcher(), result, file);
-  } else {
-    *result = PP_ERROR_BADARGUMENT;
-  }
-}
-
-void PPB_Flash_Proxy::OnHostMsgRenameFile(PP_Instance instance,
-                                          const std::string& from_path,
-                                          const std::string& to_path,
-                                          int32_t* result) {
-  EnterInstanceNoLock enter(instance);
-  if (enter.succeeded()) {
-    *result = enter.functions()->GetFlashAPI()->RenameFile(
-        instance, from_path.c_str(), to_path.c_str());
-  } else {
-    *result = PP_ERROR_BADARGUMENT;
-  }
-}
-
-void PPB_Flash_Proxy::OnHostMsgDeleteFileOrDir(PP_Instance instance,
-                                               const std::string& path,
-                                               PP_Bool recursive,
-                                               int32_t* result) {
-  EnterInstanceNoLock enter(instance);
-  if (enter.succeeded()) {
-    *result = enter.functions()->GetFlashAPI()->DeleteFileOrDir(
-        instance, path.c_str(), recursive);
-  } else {
-    *result = PP_ERROR_BADARGUMENT;
-  }
-}
-
-void PPB_Flash_Proxy::OnHostMsgCreateDir(PP_Instance instance,
-                                         const std::string& path,
-                                         int32_t* result) {
-  EnterInstanceNoLock enter(instance);
-  if (enter.succeeded()) {
-    *result = enter.functions()->GetFlashAPI()->CreateDir(
-        instance, path.c_str());
-  } else {
-    *result = PP_ERROR_BADARGUMENT;
-  }
-}
-
-void PPB_Flash_Proxy::OnHostMsgQueryFile(PP_Instance instance,
-                                         const std::string& path,
-                                         PP_FileInfo* info,
-                                         int32_t* result) {
-  EnterInstanceNoLock enter(instance);
-  if (enter.succeeded()) {
-    *result = enter.functions()->GetFlashAPI()->QueryFile(
-        instance, path.c_str(), info);
-  } else {
-    *result = PP_ERROR_BADARGUMENT;
-  }
-}
-
-void PPB_Flash_Proxy::OnHostMsgGetDirContents(
-    PP_Instance instance,
-    const std::string& path,
-    std::vector<SerializedDirEntry>* entries,
-    int32_t* result) {
-  EnterInstanceNoLock enter(instance);
-  if (enter.failed()) {
-    *result = PP_ERROR_BADARGUMENT;
-    return;
-  }
-
-  PP_DirContents_Dev* contents = NULL;
-  *result = enter.functions()->GetFlashAPI()->GetDirContents(
-      instance, path.c_str(), &contents);
-  if (*result != PP_OK)
-    return;
-
-  // Convert the list of entries to the serialized version.
-  entries->resize(contents->count);
-  for (int32_t i = 0; i < contents->count; i++) {
-    (*entries)[i].name.assign(contents->entries[i].name);
-    (*entries)[i].is_dir = PP_ToBool(contents->entries[i].is_dir);
-  }
-  enter.functions()->GetFlashAPI()->FreeDirContents(instance, contents);
-}
-
 void PPB_Flash_Proxy::OnHostMsgOpenFileRef(
     PP_Instance instance,
     const HostResource& host_resource,
     int32_t mode,
     IPC::PlatformFileForTransit* file_handle,
     int32_t* result) {
   EnterInstanceNoLock enter(instance);
   if (enter.failed()) {
     *result = PP_ERROR_BADARGUMENT;
     return;
@@ skipping 37 matching lines @@
   // It's rarely used enough that we just request this interface when needed.
   const PPB_Flash_Print_1_0* print_interface =
       static_cast<const PPB_Flash_Print_1_0*>(
           dispatcher()->local_get_interface()(PPB_FLASH_PRINT_INTERFACE_1_0));
   if (print_interface)
     print_interface->InvokePrinting(instance);
 }
 
 }  // namespace proxy
 }  // namespace ppapi