Proxy private UMA pepper interface for out-of-process and NaCl plugins.

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 16 matching lines @@
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/trusted/desc/nacl_desc_wrapper.h"
 #include "native_client/src/trusted/nonnacl_util/sel_ldr_launcher.h"
 #include "native_client/src/trusted/service_runtime/nacl_error_code.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_console.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/private/ppb_nacl_private.h"
-#include "ppapi/c/private/ppb_uma_private.h"
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/text_input_controller.h"
 
 #include "ppapi/native_client/src/trusted/plugin/file_utils.h"
 #include "ppapi/native_client/src/trusted/plugin/json_manifest.h"
 #include "ppapi/native_client/src/trusted/plugin/nacl_entry_points.h"
 #include "ppapi/native_client/src/trusted/plugin/nacl_subprocess.h"
 #include "ppapi/native_client/src/trusted/plugin/nexe_arch.h"
 #include "ppapi/native_client/src/trusted/plugin/plugin_error.h"
@@ skipping 49 matching lines @@
 const int64_t kSizeKBMax = 512*1024;     // very large .nexe
 const uint32_t kSizeKBBuckets = 100;
 
 const PPB_NaCl_Private* GetNaClInterface() {
   pp::Module *module = pp::Module::Get();
   CHECK(module);
   return static_cast<const PPB_NaCl_Private*>(
       module->GetBrowserInterface(PPB_NACL_PRIVATE_INTERFACE));
 }
 
-const PPB_UMA_Private* GetUMAInterface() {
-  pp::Module *module = pp::Module::Get();
-  CHECK(module);
-  return static_cast<const PPB_UMA_Private*>(
-      module->GetBrowserInterface(PPB_UMA_PRIVATE_INTERFACE));
+}  // namespace
+
+bool Plugin::EarlyInit(int argc, const char* argn[], const char* argv[]) {
+  PLUGIN_PRINTF(("Plugin::EarlyInit (instance=%p)\n",
+                 static_cast<void*>(this)));
+
+#ifdef NACL_OSX
+  // TODO(kochi): For crbug.com/102808, this is a stopgap solution for Lion
+  // until we expose IME API to .nexe. This disables any IME interference
+  // against key inputs, so you cannot use off-the-spot IME input for NaCl apps.
+  // This makes discrepancy among platforms and therefore we should remove
+  // this hack when IME API is made available.
+  // The default for non-Mac platforms is still off-the-spot IME mode.
+  pp::TextInputController(this).SetTextInputType(PP_TEXTINPUT_TYPE_NONE);
+#endif
+
+  // Remember the embed/object argn/argv pairs.
+  argn_ = new char*[argc];
+  argv_ = new char*[argc];
+  argc_ = 0;
+  for (int i = 0; i < argc; ++i) {
+    if (NULL != argn_ && NULL != argv_) {
+      argn_[argc_] = strdup(argn[i]);
+      argv_[argc_] = strdup(argv[i]);
+      if (NULL == argn_[argc_] || NULL == argv_[argc_]) {
+        // Give up on passing arguments.
+        free(argn_[argc_]);
+        free(argv_[argc_]);
+        continue;
+      }
+      ++argc_;
+    }
+  }
+  // TODO(sehr): this leaks strings if there is a subsequent failure.
+
+  // Set up the factory used to produce DescWrappers.
+  wrapper_factory_ = new nacl::DescWrapperFactory();
+  if (NULL == wrapper_factory_) {
+    return false;
+  }
+  PLUGIN_PRINTF(("Plugin::Init (wrapper_factory=%p)\n",
+                 static_cast<void*>(wrapper_factory_)));
+
+  PLUGIN_PRINTF(("Plugin::Init (return 1)\n"));
+  // Return success.
+  return true;
 }
 
-void HistogramTimeSmall(const std::string& name, int64_t ms) {
-  if (ms < 0) return;
+void Plugin::ShutDownSubprocesses() {
+  PLUGIN_PRINTF(("Plugin::ShutDownSubprocesses (this=%p)\n",
+                 static_cast<void*>(this)));
+  PLUGIN_PRINTF(("Plugin::ShutDownSubprocesses (%s)\n",
+                 main_subprocess_.detailed_description().c_str()));
 
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
+  // Shut down service runtime. This must be done before all other calls so
+  // they don't block forever when waiting for the upcall thread to exit.
+  main_subprocess_.Shutdown();
 
-  ptr->HistogramCustomTimes(pp::Var(name).pp_var(),
-                            ms,
-                            kTimeSmallMin, kTimeSmallMax,
-                            kTimeSmallBuckets);
+  PLUGIN_PRINTF(("Plugin::ShutDownSubprocess (this=%p, return)\n",
+                 static_cast<void*>(this)));
 }
 
-void HistogramTimeMedium(const std::string& name, int64_t ms) {
+void Plugin::HistogramTimeSmall(const std::string& name,
+                                int64_t ms) {
   if (ms < 0) return;
-
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-
-  ptr->HistogramCustomTimes(pp::Var(name).pp_var(),
-                            ms,
-                            kTimeMediumMin, kTimeMediumMax,
-                            kTimeMediumBuckets);
+  uma_interface_.HistogramCustomTimes(name,
+                                      ms,
+                                      kTimeSmallMin, kTimeSmallMax,
+                                      kTimeSmallBuckets);
 }
 
-void HistogramTimeLarge(const std::string& name, int64_t ms) {
+void Plugin::HistogramTimeMedium(const std::string& name,
+                                 int64_t ms) {
   if (ms < 0) return;
-
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-
-  ptr->HistogramCustomTimes(pp::Var(name).pp_var(),
-                            ms,
-                            kTimeLargeMin, kTimeLargeMax,
-                            kTimeLargeBuckets);
+  uma_interface_.HistogramCustomTimes(name,
+                                      ms,
+                                      kTimeMediumMin, kTimeMediumMax,
+                                      kTimeMediumBuckets);
 }
 
-void HistogramSizeKB(const std::string& name, int32_t sample) {
-  if (sample < 0) return;
-
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-
-  ptr->HistogramCustomCounts(pp::Var(name).pp_var(),
-                             sample,
-                             kSizeKBMin, kSizeKBMax,
-                             kSizeKBBuckets);
+void Plugin::HistogramTimeLarge(const std::string& name,
+                                int64_t ms) {
+  if (ms < 0) return;
+  uma_interface_.HistogramCustomTimes(name,
+                                      ms,
+                                      kTimeLargeMin, kTimeLargeMax,
+                                      kTimeLargeBuckets);
 }
 
-void HistogramEnumerate(const std::string& name, int sample, int maximum,
-                        int out_of_range_replacement) {
+void Plugin::HistogramSizeKB(const std::string& name,
+                             int32_t sample) {
+  if (sample < 0) return;
+  uma_interface_.HistogramCustomCounts(name,
+                                       sample,
+                                       kSizeKBMin, kSizeKBMax,
+                                       kSizeKBBuckets);
+}
+
+void Plugin::HistogramEnumerate(const std::string& name,
+                                int sample,
+                                int maximum,
+                                int out_of_range_replacement) {
   if (sample < 0 || sample >= maximum) {
     if (out_of_range_replacement < 0)
       // No replacement for bad input, abort.
       return;
     else
       // Use a specific value to signal a bad input.
       sample = out_of_range_replacement;
   }
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-  ptr->HistogramEnumeration(pp::Var(name).pp_var(), sample, maximum);
+  uma_interface_.HistogramEnumeration(name, sample, maximum);
 }
 
-void HistogramEnumerateOsArch(const std::string& sandbox_isa) {
+void Plugin::HistogramEnumerateOsArch(const std::string& sandbox_isa) {
   enum NaClOSArch {
     kNaClLinux32 = 0,
     kNaClLinux64,
     kNaClLinuxArm,
     kNaClMac32,
     kNaClMac64,
     kNaClMacArm,
     kNaClWin32,
     kNaClWin64,
     kNaClWinArm,
@@ skipping 10 matching lines @@
 #endif
 
   if (sandbox_isa == "x86-64")
     os_arch = static_cast<NaClOSArch>(os_arch + 1);
   if (sandbox_isa == "arm")
     os_arch = static_cast<NaClOSArch>(os_arch + 2);
 
   HistogramEnumerate("NaCl.Client.OSArch", os_arch, kNaClOSArchMax, -1);
 }
 
-void HistogramEnumerateLoadStatus(PluginErrorCode error_code,
-                                  bool is_installed) {
+void Plugin::HistogramEnumerateLoadStatus(PluginErrorCode error_code,
+                                          bool is_installed) {
   HistogramEnumerate("NaCl.LoadStatus.Plugin", error_code, ERROR_MAX,
                      ERROR_UNKNOWN);
 
   // Gather data to see if being installed changes load outcomes.
   const char* name = is_installed ? "NaCl.LoadStatus.Plugin.InstalledApp" :
       "NaCl.LoadStatus.Plugin.NotInstalledApp";
-  HistogramEnumerate(name, error_code, ERROR_MAX,
-                     ERROR_UNKNOWN);
+  HistogramEnumerate(name, error_code, ERROR_MAX, ERROR_UNKNOWN);
 }
 
-void HistogramEnumerateSelLdrLoadStatus(NaClErrorCode error_code,
-                                        bool is_installed) {
-  HistogramEnumerate("NaCl.LoadStatus.SelLdr", error_code, NACL_ERROR_CODE_MAX,
-                     LOAD_STATUS_UNKNOWN);
+void Plugin::HistogramEnumerateSelLdrLoadStatus(NaClErrorCode error_code,
+                                                bool is_installed) {
+  HistogramEnumerate("NaCl.LoadStatus.SelLdr", error_code,
+                     NACL_ERROR_CODE_MAX, LOAD_STATUS_UNKNOWN);
 
   // Gather data to see if being installed changes load outcomes.
   const char* name = is_installed ? "NaCl.LoadStatus.SelLdr.InstalledApp" :
       "NaCl.LoadStatus.SelLdr.NotInstalledApp";
   HistogramEnumerate(name, error_code, NACL_ERROR_CODE_MAX,
                      LOAD_STATUS_UNKNOWN);
 }
 
-void HistogramEnumerateManifestIsDataURI(bool is_data_uri) {
+void Plugin::HistogramEnumerateManifestIsDataURI(bool is_data_uri) {
   HistogramEnumerate("NaCl.Manifest.IsDataURI", is_data_uri, 2, -1);
 }
 
-void HistogramHTTPStatusCode(const std::string& name, int status) {
+void Plugin::HistogramHTTPStatusCode(const std::string& name,
+                                     int status) {
   // Log the status codes in rough buckets - 1XX, 2XX, etc.
   int sample = status / 100;
   // HTTP status codes only go up to 5XX, using "6" to indicate an internal
   // error.
   // Note: installed files may have "0" for a status code.
   if (status < 0 || status >= 600)
     sample = 6;
   HistogramEnumerate(name, sample, 7, 6);
 }
 
-}  // namespace
-
-bool Plugin::EarlyInit(int argc, const char* argn[], const char* argv[]) {
-  PLUGIN_PRINTF(("Plugin::EarlyInit (instance=%p)\n",
-                 static_cast<void*>(this)));
-
-#ifdef NACL_OSX
-  // TODO(kochi): For crbug.com/102808, this is a stopgap solution for Lion
-  // until we expose IME API to .nexe. This disables any IME interference
-  // against key inputs, so you cannot use off-the-spot IME input for NaCl apps.
-  // This makes discrepancy among platforms and therefore we should remove
-  // this hack when IME API is made available.
-  // The default for non-Mac platforms is still off-the-spot IME mode.
-  pp::TextInputController(this).SetTextInputType(PP_TEXTINPUT_TYPE_NONE);
-#endif
-
-  // Remember the embed/object argn/argv pairs.
-  argn_ = new char*[argc];
-  argv_ = new char*[argc];
-  argc_ = 0;
-  for (int i = 0; i < argc; ++i) {
-    if (NULL != argn_ && NULL != argv_) {
-      argn_[argc_] = strdup(argn[i]);
-      argv_[argc_] = strdup(argv[i]);
-      if (NULL == argn_[argc_] || NULL == argv_[argc_]) {
-        // Give up on passing arguments.
-        free(argn_[argc_]);
-        free(argv_[argc_]);
-        continue;
-      }
-      ++argc_;
-    }
-  }
-  // TODO(sehr): this leaks strings if there is a subsequent failure.
-
-  // Set up the factory used to produce DescWrappers.
-  wrapper_factory_ = new nacl::DescWrapperFactory();
-  if (NULL == wrapper_factory_) {
-    return false;
-  }
-  PLUGIN_PRINTF(("Plugin::Init (wrapper_factory=%p)\n",
-                 static_cast<void*>(wrapper_factory_)));
-
-  PLUGIN_PRINTF(("Plugin::Init (return 1)\n"));
-  // Return success.
-  return true;
-}
-
-void Plugin::ShutDownSubprocesses() {
-  PLUGIN_PRINTF(("Plugin::ShutDownSubprocesses (this=%p)\n",
-                 static_cast<void*>(this)));
-  PLUGIN_PRINTF(("Plugin::ShutDownSubprocesses (%s)\n",
-                 main_subprocess_.detailed_description().c_str()));
-
-  // Shut down service runtime. This must be done before all other calls so
-  // they don't block forever when waiting for the upcall thread to exit.
-  main_subprocess_.Shutdown();
-
-  PLUGIN_PRINTF(("Plugin::ShutDownSubprocess (this=%p, return)\n",
-                 static_cast<void*>(this)));
-}
-
-void Plugin::StartSelLdrOnMainThread(int32_t pp_error,
-                                     ServiceRuntime* service_runtime,
-                                     const SelLdrStartParams& params,
-                                     bool* success) {
-  if (pp_error != PP_OK) {
-    PLUGIN_PRINTF(("Plugin::StartSelLdrOnMainThread: non-PP_OK arg "
-                   "-- SHOULD NOT HAPPEN\n"));
-    *success = false;
-    return;
-  }
-  *success = service_runtime->StartSelLdr(params);
-  // Signal outside of StartSelLdr here, so that the write to *success
-  // is done before signaling.
-  service_runtime->SignalStartSelLdrDone();
-}
-
 bool Plugin::LoadNaClModuleCommon(nacl::DescWrapper* wrapper,
                                   NaClSubprocess* subprocess,
                                   const Manifest* manifest,
                                   bool should_report_uma,
                                   const SelLdrStartParams& params,
                                   const pp::CompletionCallback& init_done_cb,
                                   const pp::CompletionCallback& crash_cb) {
   ServiceRuntime* new_service_runtime =
       new ServiceRuntime(this, manifest, should_report_uma, init_done_cb,
                          crash_cb);
@@ skipping 32 matching lines @@
                                                            params.error_info,
                                                            crash_cb);
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleCommon (nexe_loaded=%d)\n",
                  nexe_loaded));
   if (!nexe_loaded) {
     return false;
   }
   return true;
 }
 
+void Plugin::StartSelLdrOnMainThread(int32_t pp_error,
+                                     ServiceRuntime* service_runtime,
+                                     const SelLdrStartParams& params,
+                                     bool* success) {
+  if (pp_error != PP_OK) {
+    PLUGIN_PRINTF(("Plugin::StartSelLdrOnMainThread: non-PP_OK arg "
+                   "-- SHOULD NOT HAPPEN\n"));
+    *success = false;
+    return;
+  }
+  *success = service_runtime->StartSelLdr(params);
+  // Signal outside of StartSelLdr here, so that the write to *success
+  // is done before signaling.
+  service_runtime->SignalStartSelLdrDone();
+}
+
 bool Plugin::LoadNaClModule(nacl::DescWrapper* wrapper,
                             ErrorInfo* error_info,
                             bool enable_dyncode_syscalls,
                             bool enable_exception_handling,
                             bool enable_crash_throttling,
                             const pp::CompletionCallback& init_done_cb,
                             const pp::CompletionCallback& crash_cb) {
   // Before forking a new sel_ldr process, ensure that we do not leak
   // the ServiceRuntime object for an existing subprocess, and that any
   // associated listener threads do not go unjoined because if they
@@ skipping 257 matching lines @@
       main_subprocess_("main subprocess", NULL, NULL),
       nexe_error_reported_(false),
       wrapper_factory_(NULL),
       enable_dev_interfaces_(false),
       is_installed_(false),
       init_time_(0),
       ready_time_(0),
       nexe_size_(0),
       time_of_last_progress_event_(0),
       exit_status_(-1),
-      nacl_interface_(NULL) {
+      nacl_interface_(NULL),
+      uma_interface_(this) {
   PLUGIN_PRINTF(("Plugin::Plugin (this=%p, pp_instance=%"
                  NACL_PRId32 ")\n", static_cast<void*>(this), pp_instance));
   callback_factory_.Initialize(this);
   nexe_downloader_.Initialize(this);
   nacl_interface_ = GetNaClInterface();
   CHECK(nacl_interface_ != NULL);
   set_nacl_ready_state(UNSENT);
   set_last_error_string("");
   // We call set_exit_status() here to ensure that the 'exitStatus' property is
   // set. This can only be called when nacl_interface_ is not NULL.
@@ skipping 637 matching lines @@
   EnqueueProgressEvent(
       PP_NACL_EVENT_LOAD, url, length_computable, loaded_bytes, total_bytes);
   EnqueueProgressEvent(
       PP_NACL_EVENT_LOADEND, url, length_computable, loaded_bytes, total_bytes);
 
   // UMA
   HistogramEnumerateLoadStatus(ERROR_LOAD_SUCCESS, is_installed_);
 }
 
 
-// TODO(ncbray): report UMA stats
 void Plugin::ReportLoadError(const ErrorInfo& error_info) {
   PLUGIN_PRINTF(("Plugin::ReportLoadError (error='%s')\n",
                  error_info.message().c_str()));
   // For errors the user (and not just the developer) should know about,
   // report them to the renderer so the browser can display a message.
   if (error_info.error_code() == ERROR_MANIFEST_PROGRAM_MISSING_ARCH) {
     // A special case: the manifest may otherwise be valid but is missing
     // a program/file compatible with the user's sandbox.
     nacl_interface()->ReportNaClError(pp_instance(),
                                       PP_NACL_MANIFEST_MISSING_ARCH);
@@ skipping 268 matching lines @@
   DCHECK(pp::Module::Get()->core()->IsMainThread());
   DCHECK(nacl_interface_);
   exit_status_ = exit_status;
   nacl_interface_->SetReadOnlyProperty(pp_instance(),
                                        pp::Var("exitStatus").pp_var(),
                                        pp::Var(exit_status_).pp_var());
 }
 
 
 }  // namespace plugin