PPAPI: Move some of NexeFileDidOpen to NexeLoadManager

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/command_line.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 458 matching lines @@
   if (load_manager) {
     nacl::NexeLoadManager::ProgressEvent event(event_type);
     event.resource_url = resource_url;
     event.length_is_computable = PP_ToBool(length_is_computable);
     event.loaded_bytes = loaded_bytes;
     event.total_bytes = total_bytes;
     load_manager->DispatchEvent(event);
   }
 }
 
+void NexeFileDidOpen(PP_Instance instance,
+                     int32_t pp_error,
+                     int32_t fd,
+                     int32_t http_status,
+                     int64_t nexe_bytes_read,
+                     const char* url) {
+  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+  if (load_manager) {
+    load_manager->NexeFileDidOpen(pp_error,
+                                  fd,
+                                  http_status,
+                                  nexe_bytes_read,
+                                  url);
+  }
+}
+
 void ReportLoadSuccess(PP_Instance instance,
                        const char* url,
                        uint64_t loaded_bytes,
                        uint64_t total_bytes) {
   nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     load_manager->ReportLoadSuccess(url, loaded_bytes, total_bytes);
 }
 
 void ReportLoadError(PP_Instance instance,
@@ skipping 21 matching lines @@
   scoped_ptr<nacl::NexeLoadManager> new_load_manager(
       new nacl::NexeLoadManager(instance));
   NexeLoadManagerMap& map = g_load_manager_map.Get();
   DLOG_IF(ERROR, map.count(instance) != 0) << "Instance count should be 0";
   map.add(instance, new_load_manager.Pass());
 }
 
 void InstanceDestroyed(PP_Instance instance) {
   NexeLoadManagerMap& map = g_load_manager_map.Get();
   DLOG_IF(ERROR, map.count(instance) == 0) << "Could not find instance ID";
+  // The erase may call NexeLoadManager's destructor prior to removing it from
+  // the map. In that case, it is possible for the trusted Plugin to re-enter
+  // the NexeLoadManager (e.g., by calling ReportLoadError). Passing out the
+  // NexeLoadManager to a local scoped_ptr just ensures that its entry is gone
+  // from the map prior to the destructor being invoked.
+  scoped_ptr<nacl::NexeLoadManager> temp(map.take(instance));
   map.erase(instance);
 }
 
 PP_Bool NaClDebugEnabledForURL(const char* alleged_nmf_url) {
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableNaClDebug))
     return PP_FALSE;
   bool should_debug;
   IPC::Sender* sender = content::RenderThread::Get();
   DCHECK(sender);
   if(!sender->Send(new NaClHostMsg_NaClDebugEnabledForURL(
@@ skipping 92 matching lines @@
 }
 
 int64_t GetNexeSize(PP_Instance instance) {
   nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (load_manager)
     return load_manager->nexe_size();
   return 0;
 }
 
-void SetNexeSize(PP_Instance instance, int64_t nexe_size) {
-  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
-  DCHECK(load_manager);
-  if (load_manager)
-    return load_manager->set_nexe_size(nexe_size);
-}
-
 const PPB_NaCl_Private nacl_interface = {
   &LaunchSelLdr,
   &StartPpapiProxy,
   &UrandomFD,
   &Are3DInterfacesDisabled,
   &BrokerDuplicateHandle,
   &GetReadonlyPnaclFD,
   &CreateTemporaryFile,
   &GetNumberOfProcessors,
   &IsNonSFIModeEnabled,
   &GetNexeFd,
   &ReportTranslationFinished,
   &OpenNaClExecutable,
   &DispatchEvent,
+  &NexeFileDidOpen,
   &ReportLoadSuccess,
   &ReportLoadError,
   &ReportLoadAbort,
   &NexeDidCrash,
   &InstanceCreated,
   &InstanceDestroyed,
   &NaClDebugEnabledForURL,
   &GetSandboxArch,
   &GetUrlScheme,
   &LogToConsole,
   &GetNaClReadyState,
   &SetNaClReadyState,
   &GetIsInstalled,
   &SetIsInstalled,
   &SetReadyTime,
   &GetExitStatus,
   &SetExitStatus,
   &Vlog,
   &SetInitTime,
-  &GetNexeSize,
-  &SetNexeSize
+  &GetNexeSize
 };
 
 }  // namespace
 
 namespace nacl {
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl