Pepper: Remove PPP_ManifestService.

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 <numeric>
 #include <string>
 #include <vector>
 
@@ skipping 147 matching lines @@
                         std::string* full_url,
                         PP_PNaClOptions* pnacl_options);
 
 typedef base::Callback<void(int32_t, const PP_NaClFileInfo&)>
 DownloadFileCallback;
 
 void DownloadFile(PP_Instance instance,
                   const std::string& url,
                   const DownloadFileCallback& callback);
 
+PP_Bool StartPpapiProxy(PP_Instance instance);
+
 // 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(PP_Instance pp_instance,
-                       const PPP_ManifestService* manifest_service,
-                       void* user_data)
-      : pp_instance_(pp_instance),
-        manifest_service_(*manifest_service),
-        user_data_(user_data) {
+  ManifestServiceProxy(PP_Instance pp_instance)
+      : pp_instance_(pp_instance) {
   }
 
-  virtual ~ManifestServiceProxy() {
-    Quit();
-  }
+  virtual ~ManifestServiceProxy() { }
 
   virtual void StartupInitializationComplete() OVERRIDE {
-    if (!user_data_)
-      return;
-
-    if (!PP_ToBool(
-            manifest_service_.StartupInitializationComplete(user_data_))) {
-      user_data_ = NULL;
+    if (StartPpapiProxy(pp_instance_) == PP_TRUE) {
+      JsonManifest* manifest = GetJsonManifest(pp_instance_);
+      NexeLoadManager* load_manager = GetNexeLoadManager(pp_instance_);
+      if (load_manager && manifest) {
+        std::string full_url;
+        PP_PNaClOptions pnacl_options;
+        bool uses_nonsfi_mode;
+        JsonManifest::ErrorInfo error_info;
+        if (manifest->GetProgramURL(&full_url,
+                                    &pnacl_options,
+                                    &uses_nonsfi_mode,
+                                    &error_info)) {
+          int64_t nexe_size = load_manager->nexe_size();
+          load_manager->ReportLoadSuccess(full_url, nexe_size, nexe_size);
+        }
+      }
     }
   }
 
   virtual void OpenResource(
       const std::string& key,
       const ManifestServiceChannel::OpenResourceCallback& callback) OVERRIDE {
     DCHECK(ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->
                BelongsToCurrentThread());
 
-    if (!user_data_)
-      return;
-
     std::string url;
     // TODO(teravest): Clean up pnacl_options logic in JsonManifest so we don't
     // have to initialize it like this here.
     PP_PNaClOptions pnacl_options;
     pnacl_options.translate = PP_FALSE;
     pnacl_options.is_debug = PP_FALSE;
     pnacl_options.opt_level = 2;
     if (!ManifestResolveKey(pp_instance_, false, key, &url, &pnacl_options)) {
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
@@ skipping 17 matching lines @@
       ManifestServiceChannel::OpenResourceCallback callback,
       int32_t pp_error,
       const PP_NaClFileInfo& file_info) {
     if (pp_error != PP_OK) {
       callback.Run(base::File());
       return;
     }
     callback.Run(base::File(file_info.handle));
   }
 
-  void Quit() {
-    if (!user_data_)
-      return;
-
-    bool result = PP_ToBool(manifest_service_.Quit(user_data_));
-    DCHECK(!result);
-    user_data_ = NULL;
-  }
-
   PP_Instance pp_instance_;
-  PPP_ManifestService manifest_service_;
-  void* user_data_;
   DISALLOW_COPY_AND_ASSIGN(ManifestServiceProxy);
 };
 
 blink::WebURLLoader* CreateWebURLLoader(const blink::WebDocument& document,
                                         const GURL& gurl) {
   blink::WebURLLoaderOptions options;
   options.untrustedHTTP = true;
 
   // Options settings here follow the original behavior in the trusted
   // plugin and PepperURLLoaderHost.
@@ skipping 34 matching lines @@
                   PP_Bool main_service_runtime,
                   const char* alleged_url,
                   const PP_NaClFileInfo* nexe_file_info,
                   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 PPP_ManifestService* manifest_service_interface,
-                  void* manifest_service_user_data,
                   void* imc_handle,
                   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
-  // can free manifest_service_user_data properly.
+  // destructed (without passing it to ManifestServiceChannel).
   scoped_ptr<ManifestServiceChannel::Delegate> manifest_service_proxy(
-      new ManifestServiceProxy(instance,
-                               manifest_service_interface,
-                               manifest_service_user_data));
+      new ManifestServiceProxy(instance));
 
   FileDescriptor result_socket;
   IPC::Sender* sender = content::RenderThread::Get();
   DCHECK(sender);
   int routing_id = 0;
   // If the nexe uses ppapi APIs, we need a routing ID.
   // To get the routing ID, we must be on the main thread.
   // Some nexes do not use ppapi and launch from the background thread,
   // so those nexes can skip finding a routing_id.
   if (uses_ppapi) {
@@ skipping 1305 matching lines @@
   &SetPNaClStartTime
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl