Pepper: Manifest refactoring in trusted plugin.

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 801 matching lines @@
 
 int64_t GetNexeSize(PP_Instance instance) {
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (load_manager)
     return load_manager->nexe_size();
   return 0;
 }
 
 void DownloadManifestToBuffer(PP_Instance instance,
-                              struct PP_Var* out_data,
+                              int32_t* out_manifest_id,
                               struct PP_CompletionCallback callback);
 
+int32_t CreateJsonManifest(PP_Instance instance,
+                           const std::string& manifest_url,
+                           const std::string& manifest_data);
+
 void RequestNaClManifest(PP_Instance instance,
                          const char* url,
-                         PP_Var* out_data,
+                         int32_t* out_manifest_id,
                          PP_CompletionCallback callback) {
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
     return;
   }
 
   if (!load_manager->RequestNaClManifest(url)) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
     return;
   }
 
   const GURL& base_url = load_manager->manifest_base_url();
   if (base_url.SchemeIs("data")) {
     GURL gurl(base_url);
     std::string mime_type;
     std::string charset;
     std::string data;
     int32_t error = PP_ERROR_FAILED;
     if (net::DataURL::Parse(gurl, &mime_type, &charset, &data)) {
       if (data.size() <= ManifestDownloader::kNaClManifestMaxFileBytes) {
         error = PP_OK;
-        *out_data = ppapi::StringVar::StringToPPVar(data);
+        *out_manifest_id = CreateJsonManifest(instance, base_url.spec(), data);
       } else {
         load_manager->ReportLoadError(PP_NACL_ERROR_MANIFEST_TOO_LARGE,
                                       "manifest file too large.");
       }
     } else {
       load_manager->ReportLoadError(PP_NACL_ERROR_MANIFEST_LOAD_URL,
                                     "could not load manifest url.");
     }
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data, error));
   } else {
-    DownloadManifestToBuffer(instance, out_data, callback);
+    DownloadManifestToBuffer(instance, out_manifest_id, callback);
   }
 }
 
 PP_Var GetManifestBaseURL(PP_Instance instance) {
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager)
     return PP_MakeUndefined();
   const GURL& gurl = load_manager->manifest_base_url();
   if (!gurl.is_valid())
@@ skipping 30 matching lines @@
 
 PP_Bool DevInterfacesEnabled(PP_Instance instance) {
   nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     return PP_FromBool(load_manager->DevInterfacesEnabled());
   return PP_FALSE;
 }
 
 void DownloadManifestToBufferCompletion(PP_Instance instance,
                                         struct PP_CompletionCallback callback,
-                                        struct PP_Var* out_data,
+                                        int32_t* out_manifest_id,
                                         base::Time start_time,
                                         PP_NaClError pp_nacl_error,
                                         const std::string& data);
 
 void DownloadManifestToBuffer(PP_Instance instance,
-                              struct PP_Var* out_data,
+                              int32_t* out_manifest_id,
                               struct PP_CompletionCallback callback) {
   nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!load_manager || !plugin_instance) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
   }
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->element().document();
 
   const GURL& gurl = load_manager->manifest_base_url();
   scoped_ptr<blink::WebURLLoader> url_loader(
       CreateWebURLLoader(document, gurl));
   blink::WebURLRequest request = CreateWebURLRequest(document, gurl);
 
   // ManifestDownloader deletes itself after invoking the callback.
   ManifestDownloader* manifest_downloader = new ManifestDownloader(
       url_loader.Pass(),
       load_manager->is_installed(),
       base::Bind(DownloadManifestToBufferCompletion,
-                 instance, callback, out_data, base::Time::Now()));
+                 instance, callback, out_manifest_id, base::Time::Now()));
   manifest_downloader->Load(request);
 }
 
 void DownloadManifestToBufferCompletion(PP_Instance instance,
                                         struct PP_CompletionCallback callback,
-                                        struct PP_Var* out_data,
+                                        int32_t* out_manifest_id,
                                         base::Time start_time,
                                         PP_NaClError pp_nacl_error,
                                         const std::string& data) {
   base::TimeDelta download_time = base::Time::Now() - start_time;
   HistogramTimeSmall("NaCl.Perf.StartupTime.ManifestDownload",
                      download_time.InMilliseconds());
 
   nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (!load_manager) {
     callback.func(callback.user_data, PP_ERROR_ABORTED);
@@ skipping 21 matching lines @@
                                     "access to manifest url was denied.");
       break;
     default:
       NOTREACHED();
       pp_error = PP_ERROR_FAILED;
       load_manager->ReportLoadError(PP_NACL_ERROR_MANIFEST_LOAD_URL,
                                     "could not load manifest url.");
   }
 
   if (pp_error == PP_OK) {
-    std::string contents;
-    *out_data = ppapi::StringVar::StringToPPVar(data);
+    std::string base_url = load_manager->manifest_base_url().spec();
+    *out_manifest_id = CreateJsonManifest(instance, base_url, data);
   }
   callback.func(callback.user_data, pp_error);
 }
 
 int32_t CreatePNaClManifest(PP_Instance /* instance */) {
   return GetPNaClManifestId();
 }
 
 int32_t CreateJsonManifest(PP_Instance instance,
-                           const char* manifest_url,
-                           const char* manifest_data) {
+                           const std::string& manifest_url,
+                           const std::string& manifest_data) {
+  HistogramSizeKB("NaCl.Perf.Size.Manifest",
+                  static_cast<int32_t>(manifest_data.length() / 1024));
+
   nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (!load_manager)
     return -1;
   int32_t manifest_id = g_next_manifest_id.Get();
   g_next_manifest_id.Get()++;
 
   const char* isa_type;
   if (load_manager->IsPNaCl())
     isa_type = kPortableArch;
   else
     isa_type = GetSandboxArch();
 
   scoped_ptr<nacl::JsonManifest> j(
       new nacl::JsonManifest(
-          manifest_url,
+          manifest_url.c_str(),
           isa_type,
           IsNonSFIModeEnabled(),
-          PP_ToBool(NaClDebugEnabledForURL(manifest_url))));
+          PP_ToBool(NaClDebugEnabledForURL(manifest_url.c_str()))));
   JsonManifest::ErrorInfo error_info;
-  if (j->Init(manifest_data, &error_info)) {
+  if (j->Init(manifest_data.c_str(), &error_info)) {
     g_manifest_map.Get().add(manifest_id, j.Pass());
     return manifest_id;
   }
   load_manager->ReportLoadError(error_info.error, error_info.string);
   return -1;
 }
 
 void DestroyManifest(PP_Instance /* instance */,
                      int32_t manifest_id) {
   if (manifest_id == GetPNaClManifestId())
@@ skipping 411 matching lines @@
   &Vlog,
   &InitializePlugin,
   &GetNexeSize,
   &RequestNaClManifest,
   &GetManifestBaseURL,
   &ResolvesRelativeToPluginBaseURL,
   &ProcessNaClManifest,
   &GetManifestURLArgument,
   &DevInterfacesEnabled,
   &CreatePNaClManifest,
-  &CreateJsonManifest,
   &DestroyManifest,
   &ManifestGetProgramURL,
   &ManifestResolveKey,
   &GetPNaClResourceInfo,
   &GetCpuFeatureAttrs,
   &PostMessageToJavaScript,
   &DownloadNexe
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl