Implement open_resource in non-SFI mode.

components/nacl/renderer/ppb_nacl_private_impl.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 "components/nacl/renderer/ppb_nacl_private_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/containers/scoped_ptr_hash_map.h"
@@ skipping 140 matching lines @@
   }
 
  private:
   int num_remaining_calls_;
   PP_CompletionCallback callback_;
   int32_t result_;
 
   DISALLOW_COPY_AND_ASSIGN(ChannelConnectedCallback);
 };
 
-// Thin adapter from PP_ManifestService to ManifestServiceChannel::Delegate.
+// Thin adapter from PPP_ManifestService to ManifestServiceChannel::Delegate.
 // Note that user_data is managed by the caller of LaunchSelLdr. Please see
 // also PP_ManifestService's comment for more details about resource
 // management.
 class ManifestServiceProxy : public ManifestServiceChannel::Delegate {
  public:
-  ManifestServiceProxy(const PP_ManifestService* manifest_service,
+  ManifestServiceProxy(const PPP_ManifestService* manifest_service,
                        void* user_data)
       : manifest_service_(*manifest_service),
         user_data_(user_data) {
   }
 
   virtual ~ManifestServiceProxy() {
     Quit();
   }
 
   virtual void StartupInitializationComplete() OVERRIDE {
     if (!user_data_)
       return;
 
     if (!PP_ToBool(
             manifest_service_.StartupInitializationComplete(user_data_))) {
       user_data_ = NULL;
     }
   }
 
+  virtual void OpenResource(
+      const std::string& key,
+      const ManifestServiceChannel::OpenResourceCallback& callback) OVERRIDE {
+    if (!user_data_)
+      return;
+
+    // The allocated callback will be freed in DidOpenResource, which is always
+    // called regardless whether OpenResource() succeeds or fails.
+    if (!PP_ToBool(manifest_service_.OpenResource(
+            user_data_,
+            key.c_str(),
+            DidOpenResource,
+            new ManifestServiceChannel::OpenResourceCallback(callback)))) {
+      user_data_ = NULL;
+    }
+  }
+
  private:
+  static void DidOpenResource(void* user_data, PP_FileHandle file_handle) {
+    scoped_ptr<ManifestServiceChannel::OpenResourceCallback> callback(
+        static_cast<ManifestServiceChannel::OpenResourceCallback*>(user_data));
+    callback->Run(file_handle);
+  }
+
   void Quit() {
     if (!user_data_)
       return;
 
     bool result = PP_ToBool(manifest_service_.Quit(user_data_));
     DCHECK(!result);
     user_data_ = NULL;
   }
 
-  PP_ManifestService manifest_service_;
+  PPP_ManifestService manifest_service_;
   void* user_data_;
   DISALLOW_COPY_AND_ASSIGN(ManifestServiceProxy);
 };
 
 // Launch NaCl's sel_ldr process.
 void LaunchSelLdr(PP_Instance instance,
                   const char* alleged_url,
                   PP_Bool uses_irt,
                   PP_Bool uses_ppapi,
                   PP_Bool uses_nonsfi_mode,
                   PP_Bool enable_ppapi_dev,
                   PP_Bool enable_dyncode_syscalls,
                   PP_Bool enable_exception_handling,
                   PP_Bool enable_crash_throttling,
-                  const PP_ManifestService* manifest_service_interface,
+                  const PPP_ManifestService* manifest_service_interface,
                   void* manifest_service_user_data,
                   void* imc_handle,
                   struct PP_Var* error_message,
                   PP_CompletionCallback callback) {
   CHECK(ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->
             BelongsToCurrentThread());
 
   // Create the manifest service proxy here, so on error case, it will be
   // destructed (without passing it to ManifestServiceChannel), and QUIT
   // will be called in its destructor so that the caller of this function
@@ skipping 96 matching lines @@
   } else {
     connected_callback.Run(PP_ERROR_FAILED);
   }
 
   // Stash the manifest service handle as well.
   if (load_manager &&
       IsValidChannelHandle(
           launch_result.manifest_service_ipc_channel_handle)) {
     scoped_ptr<ManifestServiceChannel> manifest_service_channel(
         new ManifestServiceChannel(
+            !enable_dyncode_syscalls,  // true, on a plugin in PNaCl mode.

[Mark Seaborn, 2014/05/01 06:32:35]

Actually, let's make this stricter and use:
  !enable_dyncode_syscalls && uses_nonsfi_mode

Checking uses_nonsfi_mode would be enough, but adding "!enable_dyncode_syscalls"
better captures the future intent.

Can you comment the reason?  Something like:

For security hardening, disable the IPCs for open_resource() when they aren't
needed.  PNaCl doesn't expose open_resource(), and the new open_resource() IPCs
are currently only used for Non-SFI NaCl so far, not SFI NaCl.

[hidehiko, 2014/05/01 13:05:40]

Done.

             launch_result.manifest_service_ipc_channel_handle,
             connected_callback,
             manifest_service_proxy.Pass(),
             content::RenderThread::Get()->GetShutdownEvent()));
     load_manager->set_manifest_service_channel(
         manifest_service_channel.Pass());
   } else {
     // Currently, manifest service works only on linux/non-SFI mode.
     // On other platforms, the socket will not be created, and thus this
     // condition needs to be handled as success.
@@ skipping 553 matching lines @@
   &DevInterfacesEnabled
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl