Pepper: Move FileRef to the "new" resource proxy.

ppapi/proxy/file_ref_resource.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 "ppapi/proxy/file_ref_resource.h"
 
 #include "ppapi/c/pp_directory_entry.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/array_writer.h"
 #include "ppapi/shared_impl/file_ref_util.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/resource_tracker.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_file_system_api.h"
 
 namespace ppapi {
 namespace proxy {
 
 FileRefResource::FileRefResource(
     Connection connection,
     PP_Instance instance,
-    const FileRef_CreateInfo& create_info)
+    const FileRefCreateInfo& create_info)
     : PluginResource(connection, instance),
       create_info_(create_info),
       file_system_resource_(create_info.file_system_plugin_resource) {
   if (create_info_.file_system_type != PP_FILESYSTEMTYPE_EXTERNAL) {
     // If path ends with a slash, then normalize it away unless path is
     // the root path.
     int path_size = create_info_.internal_path.size();
     if (path_size > 1 && create_info_.internal_path.at(path_size - 1) == '/')
       create_info_.internal_path.erase(path_size - 1, 1);
 
     path_var_ = new StringVar(create_info_.internal_path);
-
     create_info_.display_name = GetNameForInternalFilePath(
         create_info_.internal_path);
   }
   name_var_ = new StringVar(create_info_.display_name);
 
-  if (create_info_.pending_host_resource_id != 0) {
-    AttachToPendingHost(BROWSER, create_info_.pending_host_resource_id);
+  if (create_info_.browser_pending_host_resource_id != 0 &&

[yzshen1, 2013/09/04 18:31:49]

Do we need to handle the case in which one of them is not 0 while the other is?

[teravest, 2013/09/04 19:28:46]

I'm not sure what the right thing is to do in that case. Today we'd have a CHECK
failure. I can't think of anything much better to do.

[yzshen1, 2013/09/04 20:27:24]

It is better to explicitly handle that case, either CHECK/DCHECK or using a
static Create() function so that we can return NULL on failure.
I don't think it is very important, maybe DCHECK is good enough.


On 2013/09/04 19:28:46, teravest wrote:

+      create_info_.renderer_pending_host_resource_id != 0) {
+    AttachToPendingHost(BROWSER, create_info_.browser_pending_host_resource_id);
+    AttachToPendingHost(RENDERER,
+                        create_info_.renderer_pending_host_resource_id);
   } else {
     CHECK(create_info_.file_system_type != PP_FILESYSTEMTYPE_EXTERNAL);
     SendCreate(BROWSER, PpapiHostMsg_FileRef_CreateInternal(
         create_info.file_system_plugin_resource,
         create_info.internal_path));
+    SendCreate(RENDERER, PpapiHostMsg_FileRef_CreateInternal(
+        create_info.file_system_plugin_resource,
+        create_info.internal_path));
   }
 }
 
 FileRefResource::~FileRefResource() {
 }
 
 //static
 PP_Resource FileRefResource::CreateFileRef(
     Connection connection,
     PP_Instance instance,
-    const FileRef_CreateInfo& create_info) {
+    const FileRefCreateInfo& create_info) {
   // If we have a valid file_system resource, ensure that its type matches that
   // of the fs_type parameter.
   if (create_info.file_system_plugin_resource != 0) {
     thunk::EnterResourceNoLock<thunk::PPB_FileSystem_API> enter(
         create_info.file_system_plugin_resource, true);
     if (enter.failed())
       return 0;
     if (enter.object()->GetType() != create_info.file_system_type) {
       NOTREACHED() << "file system type mismatch with resource";
       return 0;
     }
   }
 
   if (create_info.file_system_type == PP_FILESYSTEMTYPE_LOCALPERSISTENT ||
       create_info.file_system_type == PP_FILESYSTEMTYPE_LOCALTEMPORARY) {
     if (!IsValidInternalPath(create_info.internal_path))
       return 0;
   }
   return (new FileRefResource(connection,
                               instance,
                               create_info))->GetReference();
 }
 
 thunk::PPB_FileRef_API* FileRefResource::AsPPB_FileRef_API() {
-  // TODO: return "this" once we update PPB_FileRef_API.
-  NOTREACHED();
-  return NULL;
+  return this;
 }
 
 PP_FileSystemType FileRefResource::GetFileSystemType() const {
   return create_info_.file_system_type;
 }
 
 PP_Var FileRefResource::GetName() const {
   return name_var_->GetPPVar();
 }
 
 PP_Var FileRefResource::GetPath() const {
   if (create_info_.file_system_type == PP_FILESYSTEMTYPE_EXTERNAL)
     return PP_MakeUndefined();
   return path_var_->GetPPVar();
 }
 
 PP_Resource FileRefResource::GetParent() {
   if (create_info_.file_system_type == PP_FILESYSTEMTYPE_EXTERNAL)
     return 0;
 
   size_t pos = create_info_.internal_path.rfind('/');
   CHECK(pos != std::string::npos);
   if (pos == 0)
     pos++;
   std::string parent_path = create_info_.internal_path.substr(0, pos);
 
-  ppapi::FileRef_CreateInfo parent_info;
+  ppapi::FileRefCreateInfo parent_info;
   parent_info.file_system_type = create_info_.file_system_type;
   parent_info.internal_path = parent_path;
   parent_info.display_name = GetNameForInternalFilePath(parent_path);
   parent_info.file_system_plugin_resource =
       create_info_.file_system_plugin_resource;
 
   return (new FileRefResource(connection(),
                               pp_instance(),
                               parent_info))->GetReference();
 }
@@ skipping 52 matching lines @@
     const PP_ArrayOutput& output,
     scoped_refptr<TrackedCallback> callback) {
   Call<PpapiPluginMsg_FileRef_ReadDirectoryEntriesReply>(
       BROWSER,
       PpapiHostMsg_FileRef_ReadDirectoryEntries(),
       base::Bind(&FileRefResource::OnDirectoryEntriesReply,
                  this, output, callback));
   return PP_OK_COMPLETIONPENDING;
 }
 
-/*
-const FileRef_CreateInfo& FileRefResource::GetCreateInfo() const {
+const FileRefCreateInfo& FileRefResource::GetCreateInfo() const {
   return create_info_;
 }
-*/
-const PPB_FileRef_CreateInfo& FileRefResource::GetCreateInfo() const {
-  // FIXME
-  NOTREACHED();
-  PPB_FileRef_CreateInfo *info = new PPB_FileRef_CreateInfo();
-  return *info;
-}
-
-// TODO(teravest): Remove this when we are finished moving to the new proxy.
-int32_t FileRefResource::QueryInHost(linked_ptr<PP_FileInfo> info,
-                                    scoped_refptr<TrackedCallback> callback) {
-  NOTREACHED();
-  return PP_ERROR_FAILED;
-}
-
-// TODO(teravest): Remove this when we are finished moving to the new proxy.
-int32_t FileRefResource::ReadDirectoryEntriesInHost(
-    linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files,
-    linked_ptr<std::vector<PP_FileType> > file_types,
-    scoped_refptr<TrackedCallback> callback) {
-  NOTREACHED();
-  return PP_ERROR_FAILED;
-}
 
 PP_Var FileRefResource::GetAbsolutePath() {
   if (!absolute_path_var_.get()) {
     std::string absolute_path;
     int32_t result = SyncCall<PpapiPluginMsg_FileRef_GetAbsolutePathReply>(
         BROWSER, PpapiHostMsg_FileRef_GetAbsolutePath(), &absolute_path);
     if (result != PP_OK)
       return PP_MakeUndefined();
     absolute_path_var_ = new StringVar(absolute_path);
   }
@@ skipping 17 matching lines @@
 
   if (params.result() == PP_OK)
     *out_info = info;
   callback->Run(params.result());
 }
 
 void FileRefResource::OnDirectoryEntriesReply(
     const PP_ArrayOutput& output,
     scoped_refptr<TrackedCallback> callback,
     const ResourceMessageReplyParams& params,
-    const std::vector<ppapi::FileRef_CreateInfo>& infos,
+    const std::vector<ppapi::FileRefCreateInfo>& infos,
     const std::vector<PP_FileType>& file_types) {
   if (!TrackedCallback::IsPending(callback))
     return;
 
   if (params.result() == PP_OK) {
     ArrayWriter writer(output);
     if (!writer.is_valid()) {
       callback->Run(PP_ERROR_BADARGUMENT);
       return;
     }
 
     std::vector<PP_DirectoryEntry> entries;
     for (size_t i = 0; i < infos.size(); ++i) {
       PP_DirectoryEntry entry;
       entry.file_ref = FileRefResource::CreateFileRef(connection(),
                                                       pp_instance(),
                                                       infos[i]);
       entry.file_type = file_types[i];
       entries.push_back(entry);
     }
 
     writer.StoreVector(entries);
   }
   callback->Run(params.result());
 }
 
 }  // namespace proxy
 }  // namespace ppapi