Pepper: Delete FileDownloader in trusted plugin.

ppapi/native_client/src/trusted/plugin/pnacl_coordinator.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.
 
 #include "ppapi/native_client/src/trusted/plugin/pnacl_coordinator.h"
 
 #include <utility>
 #include <vector>
 
 #include "native_client/src/include/checked_cast.h"
@@ skipping 45 matching lines @@
   uma.HistogramEnumeration("NaCl.Perf.PNaClCache.IsHit",
                            hit, 2);
 }
 
 nacl::string GetArchitectureAttributes(Plugin* plugin) {
   pp::Var attrs_var(pp::PASS_REF,
                     plugin->nacl_interface()->GetCpuFeatureAttrs());
   return attrs_var.AsString();
 }
 
+void DidCacheHit(void* user_data, PP_FileHandle nexe_file_handle) {
+  PnaclCoordinator* coordinator = static_cast<PnaclCoordinator*>(user_data);
+  coordinator->BitcodeStreamCacheHit(nexe_file_handle);
+}
+
+void DidCacheMiss(void* user_data, int64_t expected_pexe_size) {
+  PnaclCoordinator* coordinator = static_cast<PnaclCoordinator*>(user_data);
+  coordinator->BitcodeStreamCacheMiss(expected_pexe_size);
+}
+
+void DidStreamData(void* user_data, const void* stream_data, int32_t length) {
+  PnaclCoordinator* coordinator = static_cast<PnaclCoordinator*>(user_data);
+  coordinator->BitcodeStreamGotData(stream_data, length);
+}
+
+void DidFinishStream(void* user_data, int32_t pp_error) {
+  PnaclCoordinator* coordinator = static_cast<PnaclCoordinator*>(user_data);
+  coordinator->BitcodeStreamDidFinish(pp_error);
+}
+
+PPP_PexeStreamHandler kPexeStreamHandler = {
+  &DidCacheHit,
+  &DidCacheMiss,
+  &DidStreamData,
+  &DidFinishStream
+};
+
 }  // namespace
 
-// Out-of-line destructor to keep it from getting put in every .o where
-// callback_source.h is included
-template<>
-CallbackSource<FileStreamData>::~CallbackSource() {}
-
 PnaclCoordinator* PnaclCoordinator::BitcodeToNative(
     Plugin* plugin,
     const nacl::string& pexe_url,
     const PP_PNaClOptions& pnacl_options,
     const pp::CompletionCallback& translate_notify_callback) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeToNative (plugin=%p, pexe=%s)\n",
                  static_cast<void*>(plugin), pexe_url.c_str()));
   PnaclCoordinator* coordinator =
       new PnaclCoordinator(plugin, pexe_url,
                            pnacl_options,
@@ skipping 17 matching lines @@
     const PP_PNaClOptions& pnacl_options,
     const pp::CompletionCallback& translate_notify_callback)
   : translate_finish_error_(PP_OK),
     plugin_(plugin),
     translate_notify_callback_(translate_notify_callback),
     translation_finished_reported_(false),
     pexe_url_(pexe_url),
     pnacl_options_(pnacl_options),
     architecture_attributes_(GetArchitectureAttributes(plugin)),
     split_module_count_(1),
-    is_cache_hit_(PP_FALSE),
     error_already_reported_(false),
     pexe_size_(0),
     pexe_bytes_compiled_(0),
     expected_pexe_size_(-1) {
   PLUGIN_PRINTF(("PnaclCoordinator::PnaclCoordinator (this=%p, plugin=%p)\n",
                  static_cast<void*>(this), static_cast<void*>(plugin)));
   callback_factory_.Initialize(this);
 }
 
 PnaclCoordinator::~PnaclCoordinator() {
@@ skipping 137 matching lines @@
     ReportPpapiError(PP_NACL_ERROR_PNACL_CACHE_FETCH_OTHER,
                      pp_error,
                      "Failed to open translated nexe.");
     return;
   }
 
   translate_notify_callback_.Run(pp_error);
 }
 
 void PnaclCoordinator::OpenBitcodeStream() {
-  // Now open the pexe stream.
-  streaming_downloader_.reset(new FileDownloader(plugin_));
-  // Mark the request as requesting a PNaCl bitcode file,
-  // so that component updater can detect this user action.
-  streaming_downloader_->set_request_headers(
-      "Accept: application/x-pnacl, */*");
-
-  // Even though we haven't started downloading, create the translation
-  // thread object immediately. This ensures that any pieces of the file
-  // that get downloaded before the compilation thread is accepting
-  // SRPCs won't get dropped.
-  translate_thread_.reset(new PnaclTranslateThread());
-  if (translate_thread_ == NULL) {
-    ReportNonPpapiError(
-        PP_NACL_ERROR_PNACL_THREAD_CREATE,
-        "PnaclCoordinator: could not allocate translation thread.");
-    return;
-  }
-
-  pp::CompletionCallback cb =
-      callback_factory_.NewCallback(&PnaclCoordinator::BitcodeStreamDidOpen);
-  if (!streaming_downloader_->OpenStream(pexe_url_, cb, this)) {
-    ReportNonPpapiError(
-        PP_NACL_ERROR_PNACL_PEXE_FETCH_OTHER,
-        nacl::string("PnaclCoordinator: failed to open stream ") + pexe_url_);
-    return;
-  }
-}
-
-void PnaclCoordinator::BitcodeStreamDidOpen(int32_t pp_error) {
-  if (pp_error != PP_OK) {
-    BitcodeStreamDidFinish(pp_error);
-    // We have not spun up the translation process yet, so we need to call
-    // TranslateFinished here.
-    TranslateFinished(pp_error);
-    return;
-  }
-
   // The component updater's resource throttles + OnDemand update/install
   // should block the URL request until the compiler is present. Now we
   // can load the resources (e.g. llc and ld nexes).
   resources_.reset(new PnaclResources(plugin_));
   CHECK(resources_ != NULL);
 
   // The first step of loading resources: read the resource info file.
   if (!resources_->ReadResourceInfo()) {
     ExitWithError();
     return;
   }
 
   // Second step of loading resources: call StartLoad to load pnacl-llc
   // and pnacl-ld, based on the filenames found in the resource info file.
   if (!resources_->StartLoad()) {
     ReportNonPpapiError(
         PP_NACL_ERROR_PNACL_RESOURCE_FETCH,
         nacl::string("The Portable Native Client (pnacl) component is not "
                      "installed. Please consult chrome://components for more "
                       "information."));
     return;
   }
 
-  // Okay, now that we've started the HTTP request for the pexe
-  // and we've ensured that the PNaCl compiler + metadata is installed,
-  // get the cache key from the response headers and from the
-  // compiler's version metadata.
-  nacl::string headers = streaming_downloader_->GetResponseHeaders();
-
-  temp_nexe_file_.reset(new TempFile(plugin_));
-  pp::CompletionCallback cb =
-      callback_factory_.NewCallback(&PnaclCoordinator::NexeFdDidOpen);
-  int32_t nexe_fd_err =
-      plugin_->nacl_interface()->GetNexeFd(
-          plugin_->pp_instance(),
-          streaming_downloader_->full_url().c_str(),
-          // TODO(dschuff): Get this value from the pnacl json file after it
-          // rolls in from NaCl.
-          1,
-          pnacl_options_.opt_level,
-          headers.c_str(),
-          architecture_attributes_.c_str(), // Extra compile flags.
-          &is_cache_hit_,
-          temp_nexe_file_->internal_handle(),
-          cb.pp_completion_callback());
-  if (nexe_fd_err < PP_OK_COMPLETIONPENDING) {
-    ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP, nexe_fd_err,
-                     nacl::string("Call to GetNexeFd failed"));
-  }
-}
-
-void PnaclCoordinator::NexeFdDidOpen(int32_t pp_error) {
-  PLUGIN_PRINTF(("PnaclCoordinator::NexeFdDidOpen (pp_error=%"
-                 NACL_PRId32 ", hit=%d)\n", pp_error,
-                 is_cache_hit_ == PP_TRUE));
-  if (pp_error < PP_OK) {
-    ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP, pp_error,
-                     nacl::string("GetNexeFd failed"));
+  // Even though we haven't started downloading, create the translation
+  // thread object immediately. This ensures that any pieces of the file
+  // that get downloaded before the compilation thread is accepting
+  // SRPCs won't get dropped.
+  translate_thread_.reset(new PnaclTranslateThread());
+  if (translate_thread_ == NULL) {
+    ReportNonPpapiError(
+        PP_NACL_ERROR_PNACL_THREAD_CREATE,
+        "PnaclCoordinator: could not allocate translation thread.");
     return;
   }
 
-  if (*temp_nexe_file_->internal_handle() == PP_kInvalidFileHandle) {
+  GetNaClInterface()->StreamPexe(plugin_->pp_instance(),
+                                 pexe_url_.c_str(),
+                                 pnacl_options_.opt_level,
+                                 &kPexeStreamHandler,
+                                 this);
+}
+
+void PnaclCoordinator::BitcodeStreamCacheHit(PP_FileHandle handle) {
+  HistogramEnumerateTranslationCache(plugin_->uma_interface(), true);
+  if (handle == PP_kInvalidFileHandle) {
     ReportNonPpapiError(
         PP_NACL_ERROR_PNACL_CREATE_TEMP,
         nacl::string(
             "PnaclCoordinator: Got bad temp file handle from GetNexeFd"));
+    BitcodeStreamDidFinish(PP_ERROR_FAILED);
     return;
   }
-  HistogramEnumerateTranslationCache(plugin_->uma_interface(), is_cache_hit_);
+  temp_nexe_file_.reset(new TempFile(plugin_, handle));
+  // Open it for reading as the cached nexe file.
+  NexeReadDidOpen(temp_nexe_file_->Open(false));
+}
 
-  if (is_cache_hit_ == PP_TRUE) {
-    // Cache hit -- no need to stream the rest of the file.
-    streaming_downloader_.reset(NULL);
-    // Open it for reading as the cached nexe file.
-    NexeReadDidOpen(temp_nexe_file_->Open(false));
-  } else {
-    // Open an object file first so the translator can start writing to it
-    // during streaming translation.
-    for (int i = 0; i < split_module_count_; i++) {
-      nacl::scoped_ptr<TempFile> temp_file(new TempFile(plugin_));
-      int32_t pp_error = temp_file->Open(true);
-      if (pp_error != PP_OK) {
-        ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP,
-                         pp_error,
-                         "Failed to open scratch object file.");
-        return;
-      } else {
-        obj_files_.push_back(temp_file.release());
-      }
+void PnaclCoordinator::BitcodeStreamCacheMiss(int64_t expected_pexe_size) {
+  HistogramEnumerateTranslationCache(plugin_->uma_interface(), false);
+  expected_pexe_size_ = expected_pexe_size;
+
+  for (int i = 0; i < split_module_count_; i++) {
+    PP_FileHandle obj_handle =
+        plugin_->nacl_interface()->CreateTemporaryFile(plugin_->pp_instance());
+    nacl::scoped_ptr<TempFile> temp_file(new TempFile(plugin_, obj_handle));
+    int32_t pp_error = temp_file->Open(true);
+    if (pp_error != PP_OK) {
+      ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP,
+                       pp_error,
+                       "Failed to open scratch object file.");
+      return;
+    } else {
+      obj_files_.push_back(temp_file.release());
     }
-    invalid_desc_wrapper_.reset(plugin_->wrapper_factory()->MakeInvalid());
+  }
+  invalid_desc_wrapper_.reset(plugin_->wrapper_factory()->MakeInvalid());
 
-    // Meanwhile, a miss means we know we need to stream the bitcode, so stream
-    // the rest of it now. (Calling BeginStreaming means that the downloader
-    // will begin handing data to the coordinator, which is safe any time after
-    // the translate_thread_ object has been initialized).
-    pp::CompletionCallback finish_cb = callback_factory_.NewCallback(
-        &PnaclCoordinator::BitcodeStreamDidFinish);
-    streaming_downloader_->BeginStreaming(finish_cb);
+  PP_FileHandle nexe_handle =
+      plugin_->nacl_interface()->CreateTemporaryFile(plugin_->pp_instance());
+  temp_nexe_file_.reset(new TempFile(plugin_, nexe_handle));
+  // Open the nexe file for connecting ld and sel_ldr.
+  // Start translation when done with this last step of setup!
+  RunTranslate(temp_nexe_file_->Open(true));
+}
 
-    // Open the nexe file for connecting ld and sel_ldr.
-    // Start translation when done with this last step of setup!
-    RunTranslate(temp_nexe_file_->Open(true));
-  }
+void PnaclCoordinator::BitcodeStreamGotData(const void* data, int32_t length) {
+  DCHECK(translate_thread_.get());
+
+  translate_thread_->PutBytes(data, length);
+  if (data && length > 0)
+    pexe_size_ += length;
 }
 
 void PnaclCoordinator::BitcodeStreamDidFinish(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeStreamDidFinish (pp_error=%"
                  NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_OK) {
     // Defer reporting the error and cleanup until after the translation
     // thread returns, because it may be accessing the coordinator's
     // objects or writing to the files.
     translate_finish_error_ = pp_error;
     if (pp_error == PP_ERROR_ABORTED) {
       error_info_.SetReport(PP_NACL_ERROR_PNACL_PEXE_FETCH_ABORTED,
                             "PnaclCoordinator: pexe load failed (aborted).");
     }
     if (pp_error == PP_ERROR_NOACCESS) {
       error_info_.SetReport(PP_NACL_ERROR_PNACL_PEXE_FETCH_NOACCESS,
                             "PnaclCoordinator: pexe load failed (no access).");
     } else {
       nacl::stringstream ss;
       ss << "PnaclCoordinator: pexe load failed (pp_error=" << pp_error << ").";
       error_info_.SetReport(PP_NACL_ERROR_PNACL_PEXE_FETCH_OTHER, ss.str());
     }
-    translate_thread_->AbortSubprocesses();
+
+    if (translate_thread_->started())
+      translate_thread_->AbortSubprocesses();
+    else
+      TranslateFinished(pp_error);
   } else {
     // Compare download completion pct (100% now), to compile completion pct.
     HistogramRatio(plugin_->uma_interface(),
                    "NaCl.Perf.PNaClLoadTime.PctCompiledWhenFullyDownloaded",
                    pexe_bytes_compiled_, pexe_size_);
-  }
-}
-
-void PnaclCoordinator::BitcodeStreamGotData(int32_t pp_error,
-                                            FileStreamData data) {
-  PLUGIN_PRINTF(("PnaclCoordinator::BitcodeStreamGotData (pp_error=%"
-                 NACL_PRId32 ", data=%p)\n", pp_error, data ? &(*data)[0] : 0));
-  DCHECK(translate_thread_.get());
-
-  // When we have received data, pp_error is set to the number of bytes
-  // received.
-  if (pp_error > 0) {
-    CHECK(data);
-    translate_thread_->PutBytes(data, pp_error);
-    pexe_size_ += pp_error;
-  } else {
     translate_thread_->EndStream();
   }
 }
 
-StreamCallback PnaclCoordinator::GetCallback() {
-  return callback_factory_.NewCallbackWithOutput(
-      &PnaclCoordinator::BitcodeStreamGotData);
-}
-
 void PnaclCoordinator::BitcodeGotCompiled(int32_t pp_error,
                                           int64_t bytes_compiled) {
   DCHECK(pp_error == PP_OK);
   pexe_bytes_compiled_ += bytes_compiled;
-  // If we don't know the expected total yet, ask.
-  if (expected_pexe_size_ == -1) {
-    int64_t amount_downloaded;  // dummy variable.
-    streaming_downloader_->GetDownloadProgress(&amount_downloaded,
-                                               &expected_pexe_size_);
-  }
   // Hold off reporting the last few bytes of progress, since we don't know
   // when they are actually completely compiled.  "bytes_compiled" only means
   // that bytes were sent to the compiler.
   if (expected_pexe_size_ != -1) {
     if (!ShouldDelayProgressEvent()) {
       GetNaClInterface()->DispatchEvent(plugin_->pp_instance(),
                                         PP_NACL_EVENT_PROGRESS,
                                         pexe_url_.c_str(),
                                         PP_TRUE,
                                         pexe_bytes_compiled_,
@@ skipping 36 matching lines @@
                                   invalid_desc_wrapper_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   &pnacl_options_,
                                   architecture_attributes_,
                                   this,
                                   plugin_);
 }
 
 }  // namespace plugin