PPAPI: Move some of NexeFileDidOpen to NexeLoadManager

components/nacl/renderer/nexe_load_manager.cc

 // Copyright 2014 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/nexe_load_manager.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 22 matching lines @@
 #include "third_party/WebKit/public/web/WebDOMResourceProgressEvent.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "v8/include/v8.h"
 
 namespace {
 
+void HistogramCustomCounts(const std::string& name,
+                           int32_t sample,
+                           int32_t min,
+                           int32_t max,
+                           uint32_t bucket_count) {
+  base::HistogramBase* counter =
+      base::Histogram::FactoryGet(
+          name,
+          min,
+          max,
+          bucket_count,
+          base::HistogramBase::kUmaTargetedHistogramFlag);
+  // The histogram can be NULL if it is constructed with bad arguments.  Ignore
+  // that data for this API.  An error message will be logged.
+  if (counter)
+    counter->Add(sample);
+}
+
 void HistogramEnumerate(const std::string& name,
                         int32_t sample,
                         int32_t boundary_value) {
   base::HistogramBase* counter =
       base::LinearHistogram::FactoryGet(
           name,
           1,
           boundary_value,
           boundary_value + 1,
           base::HistogramBase::kUmaTargetedHistogramFlag);
@@ skipping 75 matching lines @@
                                 base::TimeDelta td,
                                 int64_t nexe_size) {
   HistogramTimeMedium(name, static_cast<int64_t>(td.InMilliseconds()));
   if (nexe_size > 0) {
     float size_in_MB = static_cast<float>(nexe_size) / (1024.f * 1024.f);
     HistogramTimeMedium(name + "PerMB",
                         static_cast<int64_t>(td.InMilliseconds() / size_in_MB));
   }
 }
 
+void HistogramSizeKB(const std::string& name, int32_t sample) {
+  if (sample < 0) return;
+  HistogramCustomCounts(name,
+                        sample,
+                        1,
+                        512 * 1024,  // A very large .nexe.
+                        100);
+}
+
+void HistogramHTTPStatusCode(const std::string& name,
+                             int32_t 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);
+}
+
 blink::WebString EventTypeToString(PP_NaClEventType event_type) {
   switch (event_type) {
     case PP_NACL_EVENT_LOADSTART:
       return blink::WebString::fromUTF8("loadstart");
     case PP_NACL_EVENT_PROGRESS:
       return blink::WebString::fromUTF8("progress");
     case PP_NACL_EVENT_ERROR:
       return blink::WebString::fromUTF8("error");
     case PP_NACL_EVENT_ABORT:
       return blink::WebString::fromUTF8("abort");
@@ skipping 36 matching lines @@
   HistogramEnumerateOsArch(GetSandboxArch());
 }
 
 NexeLoadManager::~NexeLoadManager() {
   if (!nexe_error_reported_) {
     base::TimeDelta uptime = base::Time::Now() - ready_time_;
     HistogramTimeLarge("NaCl.ModuleUptime.Normal", uptime.InMilliseconds());
   }
 }
 
+void NexeLoadManager::NexeFileDidOpen(int32_t pp_error,
+                                      int32_t fd,
+                                      int32_t http_status,
+                                      int64_t nexe_bytes_read,
+                                      const std::string& url) {
+  // Check that we are on the main renderer thread.
+  DCHECK(content::RenderThread::Get());
+  VLOG(1) << "Plugin::NexeFileDidOpen (pp_error=" << pp_error << ")";
+  VLOG(1) << "Plugin::NexeFileDidOpen (file_desc=" << fd << ")";
+  HistogramHTTPStatusCode(
+      is_installed_ ? "NaCl.HttpStatusCodeClass.Nexe.InstalledApp" :
+                      "NaCl.HttpStatusCodeClass.Nexe.NotInstalledApp",
+      http_status);
+  // TODO(dmichael): fd is only used for error reporting here currently, and
+  // the trusted Plugin is responsible for using it and closing it.
+  // Note -1 is NACL_NO_FILE_DESC from nacl_macros.h.
+  if (pp_error != PP_OK || fd == -1) {
+    if (pp_error == PP_ERROR_ABORTED) {
+      ReportLoadAbort();
+    } else if (pp_error == PP_ERROR_NOACCESS) {
+      ReportLoadError(PP_NACL_ERROR_NEXE_NOACCESS_URL,
+                      "access to nexe url was denied.");
+    } else {
+      ReportLoadError(PP_NACL_ERROR_NEXE_LOAD_URL,
+                      "could not load nexe url.");
+    }
+    return;
+  } else if (nexe_bytes_read == -1) {
+    ReportLoadError(PP_NACL_ERROR_NEXE_STAT, "could not stat nexe file.");
+    return;
+  }
+
+  // TODO(dmichael): Can we avoid stashing away so much state?
+  nexe_size_ = nexe_bytes_read;
+  HistogramSizeKB("NaCl.Perf.Size.Nexe",
+                  static_cast<int32_t>(nexe_size_ / 1024));
+
+  // Inform JavaScript that we successfully downloaded the nacl module.
+  ProgressEvent progress_event(pp_instance_, PP_NACL_EVENT_PROGRESS, url, true,
+      nexe_size_, nexe_size_);
+  ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
+      FROM_HERE,
+      base::Bind(&NexeLoadManager::DispatchEvent,
+                 weak_factory_.GetWeakPtr(),
+                 progress_event));
+}
+
 void NexeLoadManager::ReportLoadSuccess(const std::string& url,
                                         uint64_t loaded_bytes,
                                         uint64_t total_bytes) {
   // Check that we are on the main renderer thread.
   DCHECK(content::RenderThread::Get());
   set_nacl_ready_state(PP_NACL_READY_STATE_DONE);
 
   // Inform JavaScript that loading was successful and is complete.
   ProgressEvent load_event(pp_instance_, PP_NACL_EVENT_LOAD, url, true,
       loaded_bytes, total_bytes);
@@ skipping 229 matching lines @@
   // to provide error handling.
 }
 
 void NexeLoadManager::CopyCrashLogToJsConsole(const std::string& crash_log) {
   base::StringTokenizer t(crash_log, "\n");
   while (t.GetNext())
     LogToConsole(t.token());
 }
 
 }  // namespace nacl