Non-SFI NaCl: Batch-open resource files

components/nacl/loader/nonsfi/irt_resource_open.cc

 // Copyright 2014 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 <pthread.h>
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "components/nacl/loader/nonsfi/irt_interfaces.h"
 #include "ppapi/nacl_irt/irt_manifest.h"
 
 namespace nacl {
 namespace nonsfi {
 
+namespace {
+
+pthread_mutex_t g_mu = PTHREAD_MUTEX_INITIALIZER;

[hidehiko, 2015/01/28 09:05:19]

base::Lock?

[Yusuke Sato, 2015/02/04 02:00:28]

I used this primitive type to ensure that g_mu never introduces a static
initializer. Do you know if base::Lock is always safe to use as a global
variable? If it is, I'll change.

[Mark Seaborn, 2015/02/04 18:52:16]

Indeed, I think it's not safe.  base::Lock is a non-POD type, so to use it in a
global you'd need to wrap it in a base::LazyInstance (in order to follow
Chromium's rules about not using global initialisers).

That's somewhat complex, and more expensive than using pthread_mutex_t, which
has a POD initialiser.

base::Lock exists for portability, but this file only needs to work with
NaCl/Linux toolchains.  So the trade-off is efficiency & complexity vs.
consistency with the rest of the codebase.  I think using pthread_mutex_t is OK
here.

+std::map<std::string, int>* g_fds;
+
+}  // namespace
+
+void RegisterPreopenedDescriptors(

[hidehiko, 2015/01/28 09:05:19]

Could you move the implementation to ppapi/nacl_irt/manifest_service or
something around, so that we can share the code even after switching to
nacl_helper_nonsfi?

[Mark Seaborn, 2015/02/02 23:21:50]

I agree.  This belongs in ppapi/nacl_irt/manifest_service.cc.

[Yusuke Sato, 2015/02/04 02:00:28]

Done.

[Yusuke Sato, 2015/02/04 02:00:29]

Done.

+    const std::vector<std::pair<std::string, int> >& key_fd_pairs) {
+  pthread_mutex_lock(&g_mu);

[hidehiko, 2015/01/28 09:05:19]

and base::AutoLock?

[Yusuke Sato, 2015/02/04 02:00:28]

same

+  g_fds = new std::map<std::string, int>;
+  for (size_t i = 0; i < key_fd_pairs.size(); ++i)
+    g_fds->insert(key_fd_pairs[i]);
+  pthread_mutex_unlock(&g_mu);
+}
+
+int IrtOpenResource(const char* file, int* fd) {
+  pthread_mutex_lock(&g_mu);
+  if (g_fds) {
+    std::map<std::string, int>::iterator it;
+    if (file[0] == '/')
+      it = g_fds->find(file + 1);
+    else
+      it = g_fds->find(file);
+    if (it != g_fds->end()) {
+      *fd = it->second;
+      g_fds->erase(it);
+      pthread_mutex_unlock(&g_mu);
+      return 0;
+    }
+  }
+  pthread_mutex_unlock(&g_mu);
+  return ppapi::IrtOpenResource(file, fd);
+}
+
 const nacl_irt_resource_open kIrtResourceOpen = {
-  ppapi::IrtOpenResource,
+  nacl::nonsfi::IrtOpenResource,
 };
 
 }  // namespace nonsfi
 }  // namespace nacl