Pepper: Manifest refactoring in trusted plugin.

ppapi/native_client/src/trusted/plugin/plugin.cc

 // Copyright (c) 2012 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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
@@ skipping 31 matching lines @@
 
 namespace plugin {
 
 namespace {
 
 // Up to 20 seconds
 const int64_t kTimeSmallMin = 1;         // in ms
 const int64_t kTimeSmallMax = 20000;     // in ms
 const uint32_t kTimeSmallBuckets = 100;
 
-const int64_t kSizeKBMin = 1;
-const int64_t kSizeKBMax = 512*1024;     // very large .nexe
-const uint32_t kSizeKBBuckets = 100;
-
 // Converts a PP_FileHandle to a POSIX file descriptor.
 int32_t ConvertFileDescriptor(PP_FileHandle handle) {
   PLUGIN_PRINTF(("ConvertFileDescriptor, handle=%d\n", handle));
 #if NACL_WINDOWS
   int32_t file_desc = NACL_NO_FILE_DESC;
   // On Windows, valid handles are 32 bit unsigned integers so this is safe.
   file_desc = reinterpret_cast<intptr_t>(handle);
   // Convert the Windows HANDLE from Pepper to a POSIX file descriptor.
   int32_t posix_desc = _open_osfhandle(file_desc, _O_RDWR | _O_BINARY);
   if (posix_desc == -1) {
@@ skipping 26 matching lines @@
 
 void Plugin::HistogramTimeSmall(const std::string& name,
                                 int64_t ms) {
   if (ms < 0) return;
   uma_interface_.HistogramCustomTimes(name,
                                       ms,
                                       kTimeSmallMin, kTimeSmallMax,
                                       kTimeSmallBuckets);
 }
 
-void Plugin::HistogramSizeKB(const std::string& name,
-                             int32_t sample) {
-  if (sample < 0) return;
-  uma_interface_.HistogramCustomCounts(name,
-                                       sample,
-                                       kSizeKBMin, kSizeKBMax,
-                                       kSizeKBBuckets);
-}
-
 void Plugin::HistogramEnumerateSelLdrLoadStatus(NaClErrorCode error_code) {
   if (error_code < 0 || error_code > NACL_ERROR_CODE_MAX)
     error_code = LOAD_STATUS_UNKNOWN;
 
   uma_interface_.HistogramEnumeration("NaCl.LoadStatus.SelLdr",
                                       error_code,
                                       NACL_ERROR_CODE_MAX);
 
   // Gather data to see if being installed changes load outcomes.
   const char* name = nacl_interface_->GetIsInstalled(pp_instance()) ?
@@ skipping 267 matching lines @@
 
   for (std::map<nacl::string, NaClFileInfoAutoCloser*>::iterator it =
            url_file_info_map_.begin();
        it != url_file_info_map_.end();
        ++it) {
     delete it->second;
   }
   url_downloaders_.erase(url_downloaders_.begin(), url_downloaders_.end());
 
   // Clean up accounting for our instance inside the NaCl interface.
+  if (manifest_id_ != -1)
+    nacl_interface_->DestroyManifest(pp_instance(), manifest_id_);
   nacl_interface_->InstanceDestroyed(pp_instance());
 
   // ShutDownSubprocesses shuts down the main subprocess, which shuts
   // down the main ServiceRuntime object, which kills the subprocess.
   // As a side effect of the subprocess being killed, the reverse
   // services thread(s) will get EOF on the reverse channel(s), and
   // the thread(s) will exit.  In ServiceRuntime::Shutdown, we invoke
   // ReverseService::WaitForServiceThreadsToExit(), so that there will
   // not be an extent thread(s) hanging around.  This means that the
   // ~Plugin will block until this happens.  This is a requirement,
@@ skipping 117 matching lines @@
     int64_t loaded;
     int64_t total;
     pnacl_coordinator_->GetCurrentProgress(&loaded, &total);
     ReportLoadSuccess(loaded, total);
   }
 }
 
 void Plugin::NaClManifestFileDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("Plugin::NaClManifestFileDidOpen (pp_error=%"
                  NACL_PRId32 ")\n", pp_error));
-  if (pp_error == PP_OK) {
-    // Take local ownership of manifest_data_var_
-    pp::Var manifest_data = pp::Var(pp::PASS_REF, manifest_data_var_);
-    manifest_data_var_ = PP_MakeUndefined();
-
-    std::string json_buffer = manifest_data.AsString();
-    ProcessNaClManifest(json_buffer);
-  }
-}
-
-void Plugin::ProcessNaClManifest(const nacl::string& manifest_json) {
-  HistogramSizeKB("NaCl.Perf.Size.Manifest",
-                  static_cast<int32_t>(manifest_json.length() / 1024));
-  if (!SetManifestObject(manifest_json))
+  if (pp_error != PP_OK || manifest_id_ == -1)
     return;
 
   PP_Var pp_program_url;
   PP_PNaClOptions pnacl_options = {PP_FALSE, PP_FALSE, 2};
   PP_Bool uses_nonsfi_mode;
   if (nacl_interface_->GetManifestProgramURL(pp_instance(),
           manifest_id_, &pp_program_url, &pnacl_options, &uses_nonsfi_mode)) {
     program_url_ = pp::Var(pp::PASS_REF, pp_program_url).AsString();
     // TODO(teravest): Make ProcessNaClManifest take responsibility for more of
     // this function.
@@ skipping 20 matching lines @@
     }
   }
 }
 
 void Plugin::RequestNaClManifest(const nacl::string& url) {
   PLUGIN_PRINTF(("Plugin::RequestNaClManifest (url='%s')\n", url.c_str()));
   pp::CompletionCallback open_callback =
       callback_factory_.NewCallback(&Plugin::NaClManifestFileDidOpen);
   nacl_interface_->RequestNaClManifest(pp_instance(),
                                        url.c_str(),
-                                       &manifest_data_var_,
+                                       &manifest_id_,
                                        open_callback.pp_completion_callback());
 }
 
-
-bool Plugin::SetManifestObject(const nacl::string& manifest_json) {
-  PLUGIN_PRINTF(("Plugin::SetManifestObject(): manifest_json='%s'.\n",
-       manifest_json.c_str()));
-  // Determine whether lookups should use portable (i.e., pnacl versions)
-  // rather than platform-specific files.
-  pp::Var manifest_base_url =
-      pp::Var(pp::PASS_REF, nacl_interface_->GetManifestBaseURL(pp_instance()));
-  std::string manifest_base_url_str = manifest_base_url.AsString();
-
-  int32_t manifest_id = nacl_interface_->CreateJsonManifest(
-      pp_instance(),
-      manifest_base_url_str.c_str(),
-      manifest_json.c_str());
-  if (manifest_id == -1)
-    return false;
-  manifest_id_ = manifest_id;
-  return true;
-}
-
 void Plugin::UrlDidOpenForStreamAsFile(
     int32_t pp_error,
     FileDownloader* url_downloader,
     pp::CompletionCallback callback) {
   PLUGIN_PRINTF(("Plugin::UrlDidOpen (pp_error=%" NACL_PRId32
                  ", url_downloader=%p)\n", pp_error,
                  static_cast<void*>(url_downloader)));
   url_downloaders_.erase(url_downloader);
   nacl::scoped_ptr<FileDownloader> scoped_url_downloader(url_downloader);
   NaClFileInfo tmp_info(scoped_url_downloader->GetFileInfo());
@@ skipping 189 matching lines @@
 
 void Plugin::SetExitStatusOnMainThread(int32_t pp_error,
                                        int exit_status) {
   DCHECK(pp::Module::Get()->core()->IsMainThread());
   DCHECK(nacl_interface_);
   nacl_interface_->SetExitStatus(pp_instance(), exit_status);
 }
 
 
 }  // namespace plugin