Add a component installer for Portable NaCl. Registration of installer is

chrome/nacl/pnacl_component_installer.cc

+// Copyright (c) 2011 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 "chrome/nacl/pnacl_component_installer.h"
+
+#include <string.h>
+
+#include "base/base_paths.h"
+#include "base/compiler_specific.h"
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "base/path_service.h"
+#include "base/values.h"
+#include "base/version.h"
+#include "build/build_config.h"
+#include "chrome/browser/component_updater/component_updater_service.h"
+#include "chrome/common/chrome_paths.h"
+#include "content/public/browser/browser_thread.h"
+
+using content::BrowserThread;
+
+namespace {
+
+// CRX hash. This corresponds to AppId: emkhcgigkicgidendmffimilfehocheg
+const uint8 sha256_hash[] = {
+  0x4c, 0xa7, 0x26, 0x86, 0xa8, 0x26, 0x83, 0x4d, 0x3c, 0x55,
+  0x8c, 0x8b, 0x54, 0x7e, 0x27, 0x46, 0xa0, 0xf8, 0xd5, 0x0e, 0xea,
+  0x33, 0x46, 0x6e, 0xab, 0x6c, 0xde, 0xba, 0xc0, 0x91, 0xd4, 0x5e };
+
+// One of the Pnacl component files, for checking that expected files exist.
+// TODO(jvoung): perhaps replace this with a list of the expected files in the
+// manifest.json. Use that to check that everything is unpacked.
+// However, that would make startup detection even slower (need to check for
+// more than one file!).
+const FilePath::CharType kPnaclCompilerFileName[] =
+    FILE_PATH_LITERAL("llc");
+
+// Name of the Pnacl component specified in the manifest.
+const char kPnaclManifestName[] = "PNaCl";
+
+// Name of the Pnacl architecture in the component manifest.
+// NOTE: this is independent of the Omaha query parameter.
+// TODO(jvoung): will this pre-processor define work with 64-bit Windows?
+// NaCl's sel_ldr is 64-bit, but the browser process is 32-bit.
+// Will the Omaha query do the right thing as well? If it doesn't, will
+// we need two separate Omaha queries (ouch)?
+const char kPnaclArch[] =
+#if defined(ARCH_CPU_X86)
+    "x86-32";
+#elif defined(ARCH_CPU_X86_64)
+    "x86-64";
+#elif defined(ARCH_CPU_ARMEL)
+    "arm";
+#else
+#error "Unknown Architecture in Pnacl Component Installer."
+#endif
+
+// The Pnacl components are in a directory with this name.
+const FilePath::CharType kPnaclBaseDirectory[] =
+    FILE_PATH_LITERAL("Pnacl");
+
+// If we don't have Pnacl installed, this is the version we claim.
+// TODO(jvoung): Is there a way to trick the configurator to ping the server
+// earlier if there are components that are not yet installed (version 0.0.0.0),
+// So that they will be available ASAP? Be careful not to hurt startup speed.
+// Make kNullVersion part of ComponentUpdater in that case, to avoid skew?
+const char kNullVersion[] = "0.0.0.0";
+
+// The base directory on Windows looks like:
+// <profile>\AppData\Local\Google\Chrome\User Data\Pnacl\.
+FilePath GetPnaclBaseDirectory() {
+  FilePath result;
+  PathService::Get(chrome::DIR_USER_DATA, &result);
+  return result.Append(kPnaclBaseDirectory);
+}
+
+// Pnacl components have the version encoded in the path itself
+// so we need to enumerate the directories to find the full path.
+// On success it returns something like:
+// <profile>\AppData\Local\Google\Chrome\User Data\Pnacl\0.1.2.3\.
+//
+// TODO(jvoung): Does it garbage collect old versions when a new version is
+// installed? Do we need the architecture in the path too? That is for handling
+// cases when you share a profile but switch between machine-types (or ignore
+// that odd case?).
+bool GetLatestPnaclDirectory(FilePath* result, Version* latest) {
+  *result = GetPnaclBaseDirectory();
+  bool found = false;
+  file_util::FileEnumerator
+      file_enumerator(*result, false, file_util::FileEnumerator::DIRECTORIES);
+  for (FilePath path = file_enumerator.Next(); !path.value().empty();
+       path = file_enumerator.Next()) {
+    Version version(path.BaseName().MaybeAsASCII());
+    if (!version.IsValid())
+      continue;
+    if (version.CompareTo(*latest) > 0) {
+      *latest = version;
+      *result = path;
+      found = true;
+    }
+  }
+  return found;
+}
+
+}  // namespace
+
+bool CheckPnaclComponentManifest(base::DictionaryValue* manifest,
+                                 Version* version_out) {
+  // Make sure we have the right manifest file.
+  std::string name;
+  manifest->GetStringASCII("name", &name);
+  if (name != kPnaclManifestName)
+    return false;
+
+  std::string proposed_version;
+  manifest->GetStringASCII("version", &proposed_version);
+  Version version(proposed_version.c_str());
+  if (!version.IsValid())
+    return false;
+
+  std::string arch;
+  manifest->GetStringASCII("x-pnacl-arch", &arch);
+  if (arch != kPnaclArch)
+    return false;
+
+  *version_out = version;
+  return true;
+}
+
+class PnaclComponentInstaller : public ComponentInstaller {
+ public:
+  explicit PnaclComponentInstaller(const Version& version);
+
+  virtual ~PnaclComponentInstaller() {}
+
+  virtual void OnUpdateError(int error) OVERRIDE;
+
+  virtual bool Install(base::DictionaryValue* manifest,
+                       const FilePath& unpack_path) OVERRIDE;
+
+ private:
+  Version current_version_;
+};
+
+PnaclComponentInstaller::PnaclComponentInstaller(
+    const Version& version) : current_version_(version) {
+  DCHECK(version.IsValid());
+}
+
+void PnaclComponentInstaller::OnUpdateError(int error) {
+  NOTREACHED() << "Pnacl update error: " << error;
+}
+
+bool PnaclComponentInstaller::Install(base::DictionaryValue* manifest,
+                                      const FilePath& unpack_path) {
+  Version version;
+  if (!CheckPnaclComponentManifest(manifest, &version))
+    return false;
+  if (current_version_.CompareTo(version) > 0)
+    return false;
+
+  // Make sure that at least one of the compiler files exists.
+  if (!file_util::PathExists(unpack_path.Append(kPnaclCompilerFileName)))
+    return false;
+
+  // Passed the basic tests. Time to install it.
+  FilePath path =
+      GetPnaclBaseDirectory().AppendASCII(version.GetString());
+  if (file_util::PathExists(path))
+    return false;
+  if (!file_util::Move(unpack_path, path))
+    return false;
+
+  // Installation is done. Now tell the rest of chrome (just the path service
+  // for now). TODO(jvoung): we need notifications if someone surfed to a
+  // Pnacl webpage and Pnacl was just installed at this time. They should
+  // then be able to reload the page and retry (or something).
+  current_version_ = version;
+
+  PathService::Override(chrome::FILE_PNACL_COMPONENT, path);
+  return true;
+}
+
+namespace {
+
+// Finally, do the registration with the right version number.
+void FinishPnaclUpdateRegistration(ComponentUpdateService* cus,
+                                   const Version& version) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CrxComponent pnacl;
+  pnacl.name = "pnacl";
+  pnacl.installer = new PnaclComponentInstaller(version);
+  pnacl.version = version;
+  pnacl.pk_hash.assign(sha256_hash, &sha256_hash[sizeof(sha256_hash)]);
+  if (cus->RegisterComponent(pnacl) != ComponentUpdateService::kOk) {
+    NOTREACHED() << "Pnacl component registration failed.";
+  }
+}
+
+// Check if there is an existing version on disk first to know when
+// a hosted version is actually newer.
+void StartPnaclUpdateRegistration(ComponentUpdateService* cus) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  FilePath path = GetPnaclBaseDirectory();
+  if (!file_util::PathExists(path)) {
+    if (!file_util::CreateDirectory(path)) {
+      NOTREACHED() << "Could not create Pnacl directory.";
+      return;
+    }
+  }
+
+  Version version(kNullVersion);
+  if (GetLatestPnaclDirectory(&path, &version)) {
+    // Check if one of the Pnacl files is really there.
+    FilePath compiler_path = path.Append(kPnaclCompilerFileName);
+    if (!file_util::PathExists(compiler_path)) {
+      version = Version(kNullVersion);
+    } else {
+      // Register the existing path for now, before checking for updates.
+      // TODO(jvoung): Will this always happen "early" or will it
+      // race with the NaCl plugin in browser tests?
+      PathService::Override(chrome::FILE_PNACL_COMPONENT, path);
+    }
+  }
+
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      NewRunnableFunction(&FinishPnaclUpdateRegistration, cus, version));
+}
+
+}  // namespace
+
+void RegisterPnaclComponent(ComponentUpdateService* cus) {
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+      NewRunnableFunction(&StartPnaclUpdateRegistration, cus));
+}