PPAPI/NaCl: Move event dispatching from the 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 541 matching lines @@
 char* Plugin::LookupArgument(const char* key) {
   char** keys = argn_;
   for (int ii = 0, len = argc_; ii < len; ++ii) {
     if (!strcmp(keys[ii], key)) {
       return argv_[ii];
     }
   }
   return NULL;
 }
 
-// Suggested names for progress event types, per
-// http://www.w3.org/TR/progress-events/
-const char* const Plugin::kProgressEventLoadStart = "loadstart";
-const char* const Plugin::kProgressEventProgress =  "progress";
-const char* const Plugin::kProgressEventError =     "error";
-const char* const Plugin::kProgressEventAbort =     "abort";
-const char* const Plugin::kProgressEventLoad =      "load";
-const char* const Plugin::kProgressEventLoadEnd =   "loadend";
-// Define a NaCl specific event type for .nexe crashes.
-const char* const Plugin::kProgressEventCrash =     "crash";
-
 class ProgressEvent {
  public:
-  ProgressEvent(const char* event_type,
+  ProgressEvent(PP_NaClEventType event_type,
                 const nacl::string& url,
                 Plugin::LengthComputable length_computable,
                 uint64_t loaded_bytes,
                 uint64_t total_bytes) :
     event_type_(event_type),
     url_(url),
     length_computable_(length_computable),
     loaded_bytes_(loaded_bytes),
     total_bytes_(total_bytes) { }
-  const char* event_type() const { return event_type_; }
+  PP_NaClEventType event_type() const { return event_type_; }
   const char* url() const { return url_.c_str(); }
   Plugin::LengthComputable length_computable() const {
     return length_computable_;
   }
   uint64_t loaded_bytes() const { return loaded_bytes_; }
   uint64_t total_bytes() const { return total_bytes_; }
 
  private:
-  // event_type_ is always passed from a string literal, so ownership is
-  // not taken.  Hence it does not need to be deleted when ProgressEvent is
-  // destroyed.
-  const char* event_type_;
+  PP_NaClEventType event_type_;
   nacl::string url_;
   Plugin::LengthComputable length_computable_;
   uint64_t loaded_bytes_;
   uint64_t total_bytes_;
 };
 
 const char* const Plugin::kNaClMIMEType = "application/x-nacl";
 const char* const Plugin::kPnaclMIMEType = "application/x-pnacl";
 
 bool Plugin::NexeIsContentHandler() const {
@@ skipping 254 matching lines @@
   size_t nexe_bytes_read = static_cast<size_t>(stat_buf.st_size);
 
   nexe_size_ = nexe_bytes_read;
   HistogramSizeKB("NaCl.Perf.Size.Nexe",
                   static_cast<int32_t>(nexe_size_ / 1024));
   HistogramStartupTimeMedium(
       "NaCl.Perf.StartupTime.NexeDownload",
       static_cast<float>(nexe_downloader_.TimeSinceOpenMilliseconds()));
 
   // Inform JavaScript that we successfully downloaded the nacl module.
-  EnqueueProgressEvent(kProgressEventProgress,
+  EnqueueProgressEvent(PP_NACL_EVENT_PROGRESS,
                        nexe_downloader_.url_to_open(),
                        LENGTH_IS_COMPUTABLE,
                        nexe_bytes_read,
                        nexe_bytes_read);
 
   load_start_ = NaClGetTimeOfDayMicroseconds();
   nacl::scoped_ptr<nacl::DescWrapper>
       wrapper(wrapper_factory()->MakeFileDesc(file_desc_ok_to_close, O_RDONLY));
   NaClLog(4, "NexeFileDidOpen: invoking LoadNaClModule\n");
   bool was_successful = LoadNaClModule(
@@ skipping 156 matching lines @@
     // Crashes will be more likely near startup, so use a medium histogram
     // instead of a large one.
     HistogramTimeMedium(
         "NaCl.ModuleUptime.Crash",
         (crash_time - ready_time_) / NACL_MICROS_PER_MILLI);
 
     nacl::string message = nacl::string("NaCl module crashed");
     set_last_error_string(message);
     AddToConsole(message);
 
-    EnqueueProgressEvent(kProgressEventCrash);
+    EnqueueProgressEvent(PP_NACL_EVENT_CRASH);
     set_nexe_error_reported(true);
   }
   // else ReportLoadError() and ReportAbortError() will be used by loading code
   // to provide error handling.
   //
   // NOTE: not all crashes during load will make it here.
   // Those in BrowserPpp::InitializeModule and creation of PPP interfaces
   // will just get reported back as PP_ERROR_FAILED.
 }
 
@@ skipping 113 matching lines @@
   ErrorInfo error_info;
   if (!SetManifestObject(manifest_json, &error_info)) {
     ReportLoadError(error_info);
     return;
   }
 
   if (manifest_->GetProgramURL(&program_url, &pnacl_options, &error_info)) {
     is_installed_ = GetUrlScheme(program_url) == SCHEME_CHROME_EXTENSION;
     nacl_ready_state_ = LOADING;
     // Inform JavaScript that we found a nexe URL to load.
-    EnqueueProgressEvent(kProgressEventProgress);
+    EnqueueProgressEvent(PP_NACL_EVENT_PROGRESS);
     if (pnacl_options.translate()) {
       pp::CompletionCallback translate_callback =
           callback_factory_.NewCallback(&Plugin::BitcodeDidTranslate);
       // Will always call the callback on success or failure.
       pnacl_coordinator_.reset(
           PnaclCoordinator::BitcodeToNative(this,
                                             program_url,
                                             pnacl_options,
                                             translate_callback));
       return;
@@ skipping 37 matching lines @@
     return;
   }
   PLUGIN_PRINTF(("Plugin::RequestNaClManifest (resolved url='%s')\n",
                  nmf_resolved_url.AsString().c_str()));
   is_installed_ = GetUrlScheme(nmf_resolved_url.AsString()) ==
       SCHEME_CHROME_EXTENSION;
   set_manifest_base_url(nmf_resolved_url.AsString());
   set_manifest_url(url);
   // Inform JavaScript that a load is starting.
   nacl_ready_state_ = OPENED;
-  EnqueueProgressEvent(kProgressEventLoadStart);
+  EnqueueProgressEvent(PP_NACL_EVENT_LOADSTART);
   bool is_data_uri = GetUrlScheme(nmf_resolved_url.AsString()) == SCHEME_DATA;
   HistogramEnumerateManifestIsDataURI(static_cast<int>(is_data_uri));
   if (is_data_uri) {
     pp::CompletionCallback open_callback =
         callback_factory_.NewCallback(&Plugin::NaClManifestBufferReady);
     // Will always call the callback on success or failure.
     CHECK(nexe_downloader_.Open(nmf_resolved_url.AsString(),
                                 DOWNLOAD_TO_BUFFER,
                                 open_callback,
                                 false,
@@ skipping 101 matching lines @@
 
 
 void Plugin::ReportLoadSuccess(LengthComputable length_computable,
                                uint64_t loaded_bytes,
                                uint64_t total_bytes) {
   // Set the readyState attribute to indicate loaded.
   nacl_ready_state_ = DONE;
   // Inform JavaScript that loading was successful and is complete.
   const nacl::string& url = nexe_downloader_.url_to_open();
   EnqueueProgressEvent(
-      kProgressEventLoad, url, length_computable, loaded_bytes, total_bytes);
+      PP_NACL_EVENT_LOAD, url, length_computable, loaded_bytes, total_bytes);
   EnqueueProgressEvent(
-      kProgressEventLoadEnd, url, length_computable, loaded_bytes, total_bytes);
+      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);
   }
 
   // Set the readyState attribute to indicate we need to start over.
   nacl_ready_state_ = DONE;
   set_nexe_error_reported(true);
   // Report an error in lastError and on the JavaScript console.
   nacl::string message = nacl::string("NaCl module load failed: ") +
       error_info.message();
   set_last_error_string(message);
   AddToConsole(nacl::string("NaCl module load failed: ") +
                error_info.console_message());
   // Inform JavaScript that loading encountered an error and is complete.
-  EnqueueProgressEvent(kProgressEventError);
-  EnqueueProgressEvent(kProgressEventLoadEnd);
+  EnqueueProgressEvent(PP_NACL_EVENT_ERROR);
+  EnqueueProgressEvent(PP_NACL_EVENT_LOADEND);
 
   // UMA
   HistogramEnumerateLoadStatus(error_info.error_code(), is_installed_);
 }
 
 
 void Plugin::ReportLoadAbort() {
   PLUGIN_PRINTF(("Plugin::ReportLoadAbort\n"));
   // Set the readyState attribute to indicate we need to start over.
   nacl_ready_state_ = DONE;
   set_nexe_error_reported(true);
   // Report an error in lastError and on the JavaScript console.
   nacl::string error_string("NaCl module load failed: user aborted");
   set_last_error_string(error_string);
   AddToConsole(error_string);
   // Inform JavaScript that loading was aborted and is complete.
-  EnqueueProgressEvent(kProgressEventAbort);
-  EnqueueProgressEvent(kProgressEventLoadEnd);
+  EnqueueProgressEvent(PP_NACL_EVENT_ABORT);
+  EnqueueProgressEvent(PP_NACL_EVENT_LOADEND);
 
   // UMA
   HistogramEnumerateLoadStatus(ERROR_LOAD_ABORTED, is_installed_);
 }
 
 void Plugin::UpdateDownloadProgress(
     PP_Instance pp_instance,
     PP_Resource pp_resource,
     int64_t /*bytes_sent*/,
     int64_t /*total_bytes_to_be_sent*/,
@@ skipping 12 matching lines @@
       // Find the URL loader that sent this notification.
       const FileDownloader* file_downloader =
           plugin->FindFileDownloader(pp_resource);
       // If not a streamed file, it must be the .nexe loader.
       if (file_downloader == NULL)
         file_downloader = &plugin->nexe_downloader_;
       nacl::string url = file_downloader->url_to_open();
       LengthComputable length_computable = (total_bytes_to_be_received >= 0) ?
           LENGTH_IS_COMPUTABLE : LENGTH_IS_NOT_COMPUTABLE;
 
-      plugin->EnqueueProgressEvent(kProgressEventProgress,
+      plugin->EnqueueProgressEvent(PP_NACL_EVENT_PROGRESS,
                                    url,
                                    length_computable,
                                    bytes_received,
                                    total_bytes_to_be_received);
     }
   }
 }
 
 const FileDownloader* Plugin::FindFileDownloader(
     PP_Resource url_loader) const {
   const FileDownloader* file_downloader = NULL;
   if (url_loader == nexe_downloader_.url_loader()) {
     file_downloader = &nexe_downloader_;
   } else {
     std::set<FileDownloader*>::const_iterator it = url_downloaders_.begin();
     while (it != url_downloaders_.end()) {
       if (url_loader == (*it)->url_loader()) {
         file_downloader = (*it);
         break;
       }
       ++it;
     }
   }
   return file_downloader;
 }
 
-void Plugin::EnqueueProgressEvent(const char* event_type) {
+void Plugin::EnqueueProgressEvent(PP_NaClEventType event_type) {
   EnqueueProgressEvent(event_type,
                        NACL_NO_URL,
                        Plugin::LENGTH_IS_NOT_COMPUTABLE,
                        Plugin::kUnknownBytes,
                        Plugin::kUnknownBytes);
 }
 
-void Plugin::EnqueueProgressEvent(const char* event_type,
+void Plugin::EnqueueProgressEvent(PP_NaClEventType event_type,
                                   const nacl::string& url,
                                   LengthComputable length_computable,
                                   uint64_t loaded_bytes,
                                   uint64_t total_bytes) {
   PLUGIN_PRINTF(("Plugin::EnqueueProgressEvent ("
                  "event_type='%s', url='%s', length_computable=%d, "
                  "loaded=%" NACL_PRIu64 ", total=%" NACL_PRIu64 ")\n",
                  event_type,
                  url.c_str(),
                  static_cast<int>(length_computable),
@@ skipping 25 matching lines @@
   if (result < 0) {
     return;
   }
   if (progress_events_.empty()) {
     PLUGIN_PRINTF(("Plugin::DispatchProgressEvent: no pending events\n"));
     return;
   }
   nacl::scoped_ptr<ProgressEvent> event(progress_events_.front());
   progress_events_.pop();
   PLUGIN_PRINTF(("Plugin::DispatchProgressEvent ("
-                 "event_type='%s', url='%s', length_computable=%d, "
+                 "event_type='%d', url='%s', length_computable=%d, "
                  "loaded=%" NACL_PRIu64 ", total=%" NACL_PRIu64 ")\n",
-                 event->event_type(),
+                 static_cast<int>(event->event_type()),
                  event->url(),
                  static_cast<int>(event->length_computable()),
                  event->loaded_bytes(),
                  event->total_bytes()));
 
-  static const char* kEventClosureJS =
-      "(function(target, type, url,"
-      "          lengthComputable, loadedBytes, totalBytes) {"
-      "    var progress_event = new ProgressEvent(type, {"
-      "        bubbles: false,"
-      "        cancelable: true,"
-      "        lengthComputable: lengthComputable,"
-      "        loaded: loadedBytes,"
-      "        total: totalBytes"
-      "      });"
-      "    progress_event.url = url;"
-      "    target.dispatchEvent(progress_event);"
-      "})";
-
-  // Create a function object by evaluating the JavaScript text.
-  // TODO(sehr, polina): We should probably cache the created function object to
-  // avoid JavaScript reparsing.
-  pp::VarPrivate exception;
-  pp::VarPrivate function_object = ExecuteScript(kEventClosureJS, &exception);
-  if (!exception.is_undefined() || !function_object.is_object()) {
-    PLUGIN_PRINTF(("Plugin::DispatchProgressEvent:"
-                   " Function object creation failed.\n"));
-    return;
-  }
-  // Get the target of the event to be dispatched.
-  pp::Var owner_element_object = GetOwnerElementObject();
-  if (!owner_element_object.is_object()) {
-    PLUGIN_PRINTF(("Plugin::DispatchProgressEvent:"
-                   " Couldn't get owner element object.\n"));
-    NACL_NOTREACHED();
-    return;
-  }
-
-  pp::Var argv[6];
-  static const uint32_t argc = NACL_ARRAY_SIZE(argv);
-  argv[0] = owner_element_object;
-  argv[1] = pp::Var(event->event_type());
-  argv[2] = pp::Var(event->url());
-  argv[3] = pp::Var(event->length_computable() == LENGTH_IS_COMPUTABLE);
-  argv[4] = pp::Var(static_cast<double>(event->loaded_bytes()));
-  argv[5] = pp::Var(static_cast<double>(event->total_bytes()));
-
-  // Dispatch the event.
-  const pp::Var default_method;
-  function_object.Call(default_method, argc, argv, &exception);
-  if (!exception.is_undefined()) {
-    PLUGIN_PRINTF(("Plugin::DispatchProgressEvent:"
-                   " event dispatch failed.\n"));
-  }
+  nacl_interface_->DispatchEvent(
+      pp_instance(),
+      event->event_type(),
+      pp::Var(event->url()).pp_var(),
+      event->length_computable() == LENGTH_IS_COMPUTABLE ? PP_TRUE : PP_FALSE,
+      event->loaded_bytes(),
+      event->total_bytes());
 }
 
 bool Plugin::OpenURLFast(const nacl::string& url,
                          FileDownloader* downloader) {
   // Fast path only works for installed file URLs.
   if (GetUrlScheme(url) != SCHEME_CHROME_EXTENSION)
     return false;
   // IMPORTANT: Make sure the document can request the given URL. If we don't
   // check, a malicious app could probe the extension system. This enforces a
   // same-origin policy which prevents the app from requesting resources from
@@ skipping 60 matching lines @@
                                           static_cast<uint32_t>(text.size()));
   const PPB_Console* console_interface =
       static_cast<const PPB_Console*>(
           module->GetBrowserInterface(PPB_CONSOLE_INTERFACE));
   console_interface->LogWithSource(pp_instance(), PP_LOGLEVEL_LOG, prefix, str);
   var_interface->Release(prefix);
   var_interface->Release(str);
 }
 
 }  // namespace plugin