android-14.0.0_r21/s

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "components/nacl/renderer/plugin/pnacl_coordinator.h"

#include <algorithm>
#include <memory>
#include <sstream>
#include <utility>

#include "base/check.h"
#include "components/nacl/renderer/plugin/plugin.h"
#include "components/nacl/renderer/plugin/plugin_error.h"
#include "components/nacl/renderer/plugin/pnacl_translate_thread.h"
#include "components/nacl/renderer/plugin/service_runtime.h"
#include "ppapi/c/pp_bool.h"
#include "ppapi/c/pp_errors.h"

namespace plugin {

namespace {

std::string GetArchitectureAttributes(Plugin* plugin) {
  pp::Var attrs_var(pp::PASS_REF,
                    nacl::PPBNaClPrivate::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,
                  PP_FileHandle temp_nexe_file) {
  PnaclCoordinator* coordinator = static_cast<PnaclCoordinator*>(user_data);
  coordinator->BitcodeStreamCacheMiss(expected_pexe_size,
                                      temp_nexe_file);
}

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);
}

constexpr PPP_PexeStreamHandler kPexeStreamHandler = {
    &DidCacheHit, &DidCacheMiss, &DidStreamData, &DidFinishStream};

}  // namespace

PnaclCoordinator* PnaclCoordinator::BitcodeToNative(
    Plugin* plugin,
    const std::string& pexe_url,
    const PP_PNaClOptions& pnacl_options,
    const pp::CompletionCallback& translate_notify_callback) {
  PnaclCoordinator* coordinator =
      new PnaclCoordinator(plugin, pexe_url,
                           pnacl_options,
                           translate_notify_callback);

  nacl::PPBNaClPrivate::SetPNaClStartTime(plugin->pp_instance());
  int cpus = nacl::PPBNaClPrivate::GetNumberOfProcessors();
  coordinator->num_threads_ = std::clamp(cpus, 1, 4);
  if (pnacl_options.use_subzero) {
    coordinator->split_module_count_ = 1;
  } else {
    coordinator->split_module_count_ = coordinator->num_threads_;
  }
  // First start a network request for the pexe, to tickle the component
  // updater's On-Demand resource throttler, and to get Last-Modified/ETag
  // cache information. We can cancel the request later if there's
  // a bitcode->nexe cache hit.
  coordinator->OpenBitcodeStream();
  return coordinator;
}

PnaclCoordinator::PnaclCoordinator(
    Plugin* plugin,
    const std::string& pexe_url,
    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_(0),
      num_threads_(0),
      error_already_reported_(false),
      pexe_size_(0),
      pexe_bytes_compiled_(0),
      expected_pexe_size_(-1) {
  callback_factory_.Initialize(this);
}

PnaclCoordinator::~PnaclCoordinator() {
  // Stopping the translate thread will cause the translate thread to try to
  // run translation_complete_callback_ on the main thread.  This destructor is
  // running from the main thread, and by the time it exits, callback_factory_
  // will have been destroyed.  This will result in the cancellation of
  // translation_complete_callback_, so no notification will be delivered.
  if (translate_thread_.get() != NULL)
    translate_thread_->AbortSubprocesses();
  if (!translation_finished_reported_) {
    nacl::PPBNaClPrivate::ReportTranslationFinished(
        plugin_->pp_instance(), PP_FALSE, pnacl_options_.opt_level,
        pnacl_options_.use_subzero, 0, 0, 0);
  }
  // Force deleting the translate_thread now. It must be deleted
  // before any scoped_* fields hanging off of PnaclCoordinator
  // since the thread may be accessing those fields.
  // It will also be accessing obj_files_.
  translate_thread_.reset(NULL);
}

PP_FileHandle PnaclCoordinator::TakeTranslatedFileHandle() {
  DCHECK(temp_nexe_file_.IsValid());
  return temp_nexe_file_.TakePlatformFile();
}

void PnaclCoordinator::ReportNonPpapiError(PP_NaClError err_code,
                                           const std::string& message) {
  ErrorInfo error_info;
  error_info.SetReport(err_code, message);
  plugin_->ReportLoadError(error_info);
  ExitWithError();
}

void PnaclCoordinator::ExitWithError() {
  // Free all the intermediate callbacks we ever created.
  // Note: this doesn't *cancel* the callbacks from the factories attached
  // to the various helper classes (e.g., pnacl_resources). Thus, those
  // callbacks may still run asynchronously.  We let those run but ignore
  // any other errors they may generate so that they do not end up running
  // translate_notify_callback_, which has already been freed.
  callback_factory_.CancelAll();
  if (!error_already_reported_) {
    error_already_reported_ = true;
    translation_finished_reported_ = true;
    nacl::PPBNaClPrivate::ReportTranslationFinished(
        plugin_->pp_instance(), PP_FALSE, pnacl_options_.opt_level,
        pnacl_options_.use_subzero, 0, 0, 0);
    translate_notify_callback_.Run(PP_ERROR_FAILED);
  }
}

// Signal that Pnacl translation completed normally.
void PnaclCoordinator::TranslateFinished(int32_t pp_error) {
  // Bail out if there was an earlier error (e.g., pexe load failure),
  // or if there is an error from the translation thread.
  if (translate_finish_error_ != PP_OK || pp_error != PP_OK) {
    plugin_->ReportLoadError(error_info_);
    ExitWithError();
    return;
  }

  // Send out one last progress event, to finish up the progress events
  // that were delayed (see the delay inserted in BitcodeGotCompiled).
  if (expected_pexe_size_ != -1) {
    pexe_bytes_compiled_ = expected_pexe_size_;
    nacl::PPBNaClPrivate::DispatchEvent(plugin_->pp_instance(),
                                        PP_NACL_EVENT_PROGRESS,
                                        pexe_url_.c_str(),
                                        PP_TRUE,
                                        pexe_bytes_compiled_,
                                        expected_pexe_size_);
  }
  int64_t nexe_size = temp_nexe_file_.GetLength();
  // The nexe is written to the temp_nexe_file_.  We must reset the file
  // pointer to be able to read it again from the beginning.
  temp_nexe_file_.Seek(base::File::FROM_BEGIN, 0);

  // Report to the browser that translation finished. The browser will take
  // care of storing the nexe in the cache.
  translation_finished_reported_ = true;
  nacl::PPBNaClPrivate::ReportTranslationFinished(
      plugin_->pp_instance(), PP_TRUE, pnacl_options_.opt_level,
      pnacl_options_.use_subzero, nexe_size, pexe_size_,
      translate_thread_->GetCompileTime());

  NexeReadDidOpen();
}

void PnaclCoordinator::NexeReadDidOpen() {
  if (!temp_nexe_file_.IsValid()) {
    ReportNonPpapiError(PP_NACL_ERROR_PNACL_CACHE_FETCH_OTHER,
                        "Failed to open translated nexe.");
    return;
  }

  translate_notify_callback_.Run(PP_OK);
}

void PnaclCoordinator::OpenBitcodeStream() {
  // 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_ = std::make_unique<PnaclTranslateThread>();
  if (translate_thread_ == NULL) {
    ReportNonPpapiError(
        PP_NACL_ERROR_PNACL_THREAD_CREATE,
        "PnaclCoordinator: could not allocate translation thread.");
    return;
  }

  nacl::PPBNaClPrivate::StreamPexe(
      plugin_->pp_instance(), pexe_url_.c_str(), pnacl_options_.opt_level,
      pnacl_options_.use_subzero, &kPexeStreamHandler, this);
}

void PnaclCoordinator::BitcodeStreamCacheHit(PP_FileHandle handle) {
  if (handle == PP_kInvalidFileHandle) {
    ReportNonPpapiError(
        PP_NACL_ERROR_PNACL_CREATE_TEMP,
        std::string(
            "PnaclCoordinator: Got bad temp file handle from GetNexeFd"));
    BitcodeStreamDidFinish(PP_ERROR_FAILED);
    return;
  }
  temp_nexe_file_ = base::File(handle);
  NexeReadDidOpen();
}

void PnaclCoordinator::BitcodeStreamCacheMiss(int64_t expected_pexe_size,
                                              PP_FileHandle nexe_handle) {
  // IMPORTANT: Make sure that PnaclResources::StartLoad() is only
  // called after you receive a response to a request for a .pexe file.
  //
  // 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_ = std::make_unique<PnaclResources>(
      plugin_, PP_ToBool(pnacl_options_.use_subzero));
  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,
        std::string("The Portable Native Client (pnacl) component is not "
                     "installed. Please consult chrome://components for more "
                      "information."));
    return;
  }

  expected_pexe_size_ = expected_pexe_size;

  for (int i = 0; i < split_module_count_; i++) {
    base::File temp_file(
        nacl::PPBNaClPrivate::CreateTemporaryFile(plugin_->pp_instance()));
    if (!temp_file.IsValid()) {
      ReportNonPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP,
                          "Failed to open scratch object file.");
      return;
    }
    obj_files_.push_back(std::move(temp_file));
  }

  temp_nexe_file_ = base::File(nexe_handle);
  // Open the nexe file for connecting ld and sel_ldr.
  // Start translation when done with this last step of setup!
  if (!temp_nexe_file_.IsValid()) {
    ReportNonPpapiError(
        PP_NACL_ERROR_PNACL_CREATE_TEMP,
        std::string(
            "PnaclCoordinator: Got bad temp file handle from writing nexe"));
    return;
  }
  LoadCompiler();
}

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) {
  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 {
      std::stringstream ss;
      ss << "PnaclCoordinator: pexe load failed (pp_error=" << pp_error << ").";
      error_info_.SetReport(PP_NACL_ERROR_PNACL_PEXE_FETCH_OTHER, ss.str());
    }

    if (translate_thread_->started())
      translate_thread_->AbortSubprocesses();
    else
      TranslateFinished(pp_error);
  } else {
    // Compare download completion pct (100% now), to compile completion pct.
    nacl::PPBNaClPrivate::LogBytesCompiledVsDownloaded(
        pnacl_options_.use_subzero, pexe_bytes_compiled_, pexe_size_);
    translate_thread_->EndStream();
  }
}

void PnaclCoordinator::BitcodeGotCompiled(int32_t pp_error,
                                          int64_t bytes_compiled) {
  DCHECK(pp_error == PP_OK);
  pexe_bytes_compiled_ += bytes_compiled;
  // 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()) {
      nacl::PPBNaClPrivate::DispatchEvent(plugin_->pp_instance(),
                                          PP_NACL_EVENT_PROGRESS,
                                          pexe_url_.c_str(),
                                          PP_TRUE,
                                          pexe_bytes_compiled_,
                                          expected_pexe_size_);
    }
  } else {
    nacl::PPBNaClPrivate::DispatchEvent(plugin_->pp_instance(),
                                        PP_NACL_EVENT_PROGRESS,
                                        pexe_url_.c_str(),
                                        PP_FALSE,
                                        pexe_bytes_compiled_,
                                        expected_pexe_size_);
  }
}

pp::CompletionCallback PnaclCoordinator::GetCompileProgressCallback(
    int64_t bytes_compiled) {
  return callback_factory_.NewCallback(&PnaclCoordinator::BitcodeGotCompiled,
                                       bytes_compiled);
}

void PnaclCoordinator::LoadCompiler() {
  base::TimeTicks compiler_load_start_time = base::TimeTicks::Now();
  pp::CompletionCallback load_finished = callback_factory_.NewCallback(
      &PnaclCoordinator::RunCompile, compiler_load_start_time);
  PnaclResources::ResourceType compiler_type = pnacl_options_.use_subzero
                                                   ? PnaclResources::SUBZERO
                                                   : PnaclResources::LLC;
  // Transfer file_info ownership to the sel_ldr launcher.
  PP_NaClFileInfo file_info = resources_->TakeFileInfo(compiler_type);
  const std::string& url = resources_->GetUrl(compiler_type);
  plugin_->LoadHelperNaClModule(url, file_info, &compiler_subprocess_,
                                load_finished);
}

void PnaclCoordinator::RunCompile(int32_t pp_error,
                                  base::TimeTicks compiler_load_start_time) {
  if (pp_error != PP_OK) {
    ReportNonPpapiError(
        PP_NACL_ERROR_PNACL_LLC_SETUP,
        "PnaclCoordinator: Compiler process could not be created.");
    return;
  }
  int64_t compiler_load_time_total =
      (base::TimeTicks::Now() - compiler_load_start_time).InMicroseconds();
  nacl::PPBNaClPrivate::LogTranslateTime("NaCl.Perf.PNaClLoadTime.LoadCompiler",
                                         compiler_load_time_total);
  nacl::PPBNaClPrivate::LogTranslateTime(
      pnacl_options_.use_subzero
          ? "NaCl.Perf.PNaClLoadTime.LoadCompiler.Subzero"
          : "NaCl.Perf.PNaClLoadTime.LoadCompiler.LLC",
      compiler_load_time_total);

  // Invoke llc followed by ld off the main thread.  This allows use of
  // blocking RPCs that would otherwise block the JavaScript main thread.
  pp::CompletionCallback report_translate_finished =
      callback_factory_.NewCallback(&PnaclCoordinator::TranslateFinished);
  pp::CompletionCallback compile_finished =
      callback_factory_.NewCallback(&PnaclCoordinator::LoadLinker);
  CHECK(translate_thread_ != NULL);
  translate_thread_->SetupState(
      report_translate_finished, &compiler_subprocess_, &ld_subprocess_,
      &obj_files_, num_threads_, &temp_nexe_file_,
      &error_info_, &pnacl_options_, architecture_attributes_, this);
  translate_thread_->RunCompile(compile_finished);
}

void PnaclCoordinator::LoadLinker(int32_t pp_error) {
  // Errors in the previous step would have skipped to TranslateFinished
  // so we only expect PP_OK here.
  DCHECK(pp_error == PP_OK);
  if (pp_error != PP_OK) {
    return;
  }
  ErrorInfo error_info;
  base::TimeTicks ld_load_start_time = base::TimeTicks::Now();
  pp::CompletionCallback load_finished = callback_factory_.NewCallback(
      &PnaclCoordinator::RunLink, ld_load_start_time);
  // Transfer file_info ownership to the sel_ldr launcher.
  PP_NaClFileInfo ld_file_info = resources_->TakeFileInfo(PnaclResources::LD);
  plugin_->LoadHelperNaClModule(resources_->GetUrl(PnaclResources::LD),
                                ld_file_info, &ld_subprocess_, load_finished);
}

void PnaclCoordinator::RunLink(int32_t pp_error,
                               base::TimeTicks ld_load_start_time) {
  if (pp_error != PP_OK) {
    ReportNonPpapiError(
        PP_NACL_ERROR_PNACL_LD_SETUP,
        "PnaclCoordinator: Linker process could not be created.");
    return;
  }
  nacl::PPBNaClPrivate::LogTranslateTime(
      "NaCl.Perf.PNaClLoadTime.LoadLinker",
      (base::TimeTicks::Now() - ld_load_start_time).InMicroseconds());
  translate_thread_->RunLink();
}

}  // namespace plugin