Turn on component updater on chromeos, only for the pnacl component.

chrome/browser/component_updater/pnacl/pnacl_component_installer.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 "chrome/browser/component_updater/pnacl/pnacl_component_installer.h"
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/component_updater/component_updater_service.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/omaha_query_params.h"
 #include "content/public/browser/browser_thread.h"
 
 using chrome::OmahaQueryParams;
 using content::BrowserThread;
 
 namespace {
 
@@ skipping 77 matching lines @@
                             &mips32_sha256_hash[sizeof(mips32_sha256_hash)]);
 #else
 #error "Add support for your architecture to Pnacl Component Installer."
 #endif
 }
 
 
 // If we don't have Pnacl installed, this is the version we claim.
 const char kNullVersion[] = "0.0.0.0";
 
-// Pnacl components have the version encoded in the path itself:
-// <profile>\AppData\Local\Google\Chrome\User Data\Pnacl\0.1.2.3\.
-// and the base directory will be:
-// <profile>\AppData\Local\Google\Chrome\User Data\Pnacl\.
-base::FilePath GetPnaclBaseDirectory() {
-  base::FilePath result;
-  CHECK(PathService::Get(chrome::DIR_PNACL_BASE, &result));
-  return result;
-}
-
-bool GetLatestPnaclDirectory(base::FilePath* latest_dir,
+bool GetLatestPnaclDirectory(PnaclComponentInstaller* pci,
+                             base::FilePath* latest_dir,
                              Version* latest_version,
                              std::vector<base::FilePath>* older_dirs) {
   // Enumerate all versions starting from the base directory.
-  base::FilePath base_dir = GetPnaclBaseDirectory();
+  base::FilePath base_dir = pci->GetPnaclBaseDirectory();
   bool found = false;
   file_util::FileEnumerator
       file_enumerator(base_dir, false, file_util::FileEnumerator::DIRECTORIES);
   for (base::FilePath path = file_enumerator.Next(); !path.value().empty();
        path = file_enumerator.Next()) {
     Version version(path.BaseName().MaybeAsASCII());
     if (!version.IsValid())
       continue;
     if (found) {
       if (version.CompareTo(*latest_version) > 0) {
@@ skipping 59 matching lines @@
   if (arch.compare(OmahaQueryParams::getNaclArch()) != 0) {
     LOG(WARNING) << "'pnacl-arch' field in manifest is invalid ("
                  << arch << " vs " << OmahaQueryParams::getNaclArch() << ")";
     return false;
   }
 
   *version_out = version;
   return true;
 }
 
-class PnaclComponentInstaller : public ComponentInstaller {
- public:
-  explicit PnaclComponentInstaller(const Version& version);
+PnaclComponentInstaller::PnaclComponentInstaller()
+    : per_user_(false),
+      cus_(NULL) {
+#if defined(OS_CHROMEOS)
+  per_user_ = true;
+#endif
+}
 
-  virtual ~PnaclComponentInstaller() {}
-
-  virtual void OnUpdateError(int error) OVERRIDE;
-
-  virtual bool Install(base::DictionaryValue* manifest,
-                       const base::FilePath& unpack_path) OVERRIDE;
-
- private:
-  Version current_version_;
-};
-
-PnaclComponentInstaller::PnaclComponentInstaller(
-    const Version& version) : current_version_(version) {
-  DCHECK(version.IsValid());
+PnaclComponentInstaller::~PnaclComponentInstaller() {
 }
 
 void PnaclComponentInstaller::OnUpdateError(int error) {
   NOTREACHED() << "Pnacl update error: " << error;
 }
 
+// Pnacl components have the version encoded in the path itself:
+// <profile>\AppData\Local\Google\Chrome\User Data\Pnacl\0.1.2.3\.
+// and the base directory will be:
+// <profile>\AppData\Local\Google\Chrome\User Data\Pnacl\.
+base::FilePath PnaclComponentInstaller::GetPnaclBaseDirectory() {
+  // For ChromeOS, temporarily make this user-dependent (for integrity) until
+  // we find a better solution.
+  // This is not ideal because of the following:
+  //   (a) We end up with per-user copies instead of a single copy
+  //   (b) The profile can change as users log in to different accounts
+  //   so we need to watch for user-login-events (see pnacl_profile_observer.h).
+  if (per_user_) {
+    DCHECK(!current_profile_path_.empty());
+    base::FilePath path = current_profile_path_.Append(
+        FILE_PATH_LITERAL("pnacl"));
+    return path;
+  } else {
+    base::FilePath result;
+    DCHECK(PathService::Get(chrome::DIR_PNACL_BASE, &result));
+    return result;
+  }
+}
+
+void PnaclComponentInstaller::OnProfileChange() {
+  // On chromeos, we want to find the --login-profile=<foo> dir.
+  // Even though the path does vary between users, the content
+  // changes when logging out and logging in.
+  ProfileManager* pm = g_browser_process->profile_manager();
+  current_profile_path_ = pm->user_data_dir().Append(
+      pm->GetInitialProfileDir());
+}
+
 namespace {
 
 bool PathContainsPnacl(const base::FilePath& base_path) {
   // Check that at least one of the compiler files exists, for the current ISA.
   std::string expected_filename("pnacl_public_");
   std::string arch = OmahaQueryParams::getNaclArch();
   expected_filename = expected_filename + SanitizeForPath(arch) +
       "_" + kPnaclCompilerFileName;
   return file_util::PathExists(base_path.AppendASCII(expected_filename));
 }
@@ skipping 11 matching lines @@
 
   Version version;
   if (!CheckPnaclComponentManifest(manifest,
                                    pnacl_manifest.get(),
                                    &version)) {
     LOG(WARNING) << "CheckPnaclComponentManifest failed, not installing.";
     return false;
   }
 
   // Don't install if the current version is actually newer.
-  if (current_version_.CompareTo(version) > 0)
+  if (current_version().CompareTo(version) > 0)
     return false;
 
   if (!PathContainsPnacl(unpack_path)) {
     LOG(WARNING) << "PathContainsPnacl check failed, not installing.";
     return false;
   }
 
   // Passed the basic tests. Time to install it.
-  base::FilePath path =
-      GetPnaclBaseDirectory().AppendASCII(version.GetString());
+  base::FilePath path = GetPnaclBaseDirectory().AppendASCII(
+      version.GetString());
   if (file_util::PathExists(path)) {
     LOG(WARNING) << "Target path already exists, not installing.";
     return false;
   }
   if (!file_util::Move(unpack_path, path)) {
     LOG(WARNING) << "Move failed, not installing.";
     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).
   // See: http://code.google.com/p/chromium/issues/detail?id=107438
-  current_version_ = version;
+  set_current_version(version);
 
   PathService::Override(chrome::DIR_PNACL_COMPONENT, path);
   return true;
 }
 
 namespace {
 
 void DoCheckForUpdate(ComponentUpdateService* cus,
                    const CrxComponent& pnacl) {
   if (cus->CheckForUpdateSoon(pnacl) != ComponentUpdateService::kOk) {
     LOG(WARNING) << "Pnacl check for update failed.";
   }
 }
 
 // Finally, do the registration with the right version number.
-void FinishPnaclUpdateRegistration(ComponentUpdateService* cus,
-                                   const Version& current_version) {
+void FinishPnaclUpdateRegistration(const Version& current_version,
+                                   PnaclComponentInstaller* pci) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  // Note: the source is the default of BANDAID, even though the
-  // crxes are hosted from CWS.
-  CrxComponent pnacl;
-  pnacl.name = "pnacl";
-  pnacl.installer = new PnaclComponentInstaller(current_version);
-  pnacl.version = current_version;
-  SetPnaclHash(&pnacl);
-  if (cus->RegisterComponent(pnacl) != ComponentUpdateService::kOk) {
+  CrxComponent pnacl_component;
+  pnacl_component.version = current_version;
+  pnacl_component.name = "pnacl";
+  pnacl_component.installer = pci;
+  pci->set_current_version(current_version);
+  SetPnaclHash(&pnacl_component);
+
+  ComponentUpdateService::Status status =
+      pci->cus()->RegisterComponent(pnacl_component);
+  if (status != ComponentUpdateService::kOk
+      && status != ComponentUpdateService::kReplaced) {
     NOTREACHED() << "Pnacl component registration failed.";
   }
 
   // If PNaCl is not yet installed but it is requested by --enable-pnacl,
   // we want it to be available "soon", so kick off an update check
   // earlier than usual.
   Version null_version(kNullVersion);
-  if (current_version.Equals(null_version)) {
+  if (pci->current_version().Equals(null_version)) {
     BrowserThread::PostDelayedTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(DoCheckForUpdate, cus, pnacl),
+        base::Bind(DoCheckForUpdate, pci->cus(), pnacl_component),
         base::TimeDelta::FromSeconds(kInitialDelaySeconds));
   }
 }
 
 // Check if there is an existing version on disk first to know when
 // a hosted version is actually newer.
-void StartPnaclUpdateRegistration(ComponentUpdateService* cus) {
+void StartPnaclUpdateRegistration(PnaclComponentInstaller* pci) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  base::FilePath path = GetPnaclBaseDirectory();
+  base::FilePath path = pci->GetPnaclBaseDirectory();
   if (!file_util::PathExists(path)) {
     if (!file_util::CreateDirectory(path)) {
       NOTREACHED() << "Could not create base Pnacl directory.";
       return;
     }
   }
 
   Version version(kNullVersion);
   std::vector<base::FilePath> older_dirs;
-  if (GetLatestPnaclDirectory(&path, &version, &older_dirs)) {
+  if (GetLatestPnaclDirectory(pci, &path, &version, &older_dirs)) {
     if (!PathContainsPnacl(path)) {
       version = Version(kNullVersion);
     } else {
       PathService::Override(chrome::DIR_PNACL_COMPONENT, path);
     }
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&FinishPnaclUpdateRegistration, cus, version));
+      base::Bind(&FinishPnaclUpdateRegistration, version, pci));
 
   // Remove older versions of PNaCl.
   for (std::vector<base::FilePath>::iterator iter = older_dirs.begin();
        iter != older_dirs.end(); ++iter) {
     file_util::Delete(*iter, true);
   }
 }
 
+void GetProfileInformation(PnaclComponentInstaller* pci) {
+  // Bail if not logged in yet.
+  if (!g_browser_process->profile_manager()->IsLoggedIn()) {
+    return;
+  }
+
+  pci->OnProfileChange();
+
+  BrowserThread::PostTask(
+     BrowserThread::FILE, FROM_HERE,
+     base::Bind(&StartPnaclUpdateRegistration, pci));
+}
+
+
 }  // namespace
 
-void RegisterPnaclComponent(ComponentUpdateService* cus,
+void PnaclComponentInstaller::RegisterPnaclComponent(
+                            ComponentUpdateService* cus,
                             const CommandLine& command_line) {
   // Only register when given the right flag.  This is important since
   // we do an early component updater check above (in DoCheckForUpdate).
   if (command_line.HasSwitch(switches::kEnablePnacl)) {
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
-        base::Bind(&StartPnaclUpdateRegistration, cus));
+    cus_ = cus;
+    // If per_user, create a profile observer to watch for logins.
+    // Only do so after cus_ is set to something non-null.
+    if (per_user_ && !profile_observer_) {
+      profile_observer_.reset(new PnaclProfileObserver(this));

[jvoung (off chromium), 2013/04/05 23:20:48]

One fix: Only create the profile observer *after* cus_ is set to something
non-null, so that ReRegister...() cannot get called and start using cus_ before
the cus_ is actually set.

+    }
+    if (per_user_) {
+      // Figure out profile information, before proceeding to look for files.
+      BrowserThread::PostTask(
+           BrowserThread::UI, FROM_HERE,

[jvoung (off chromium), 2013/04/05 23:20:48]

One fix: was only supposed to check profile_manager() from the UI thread.

Now all the profile_manager() bits get queried during GetProfileInformation()
and the bits are stored in the installer (mainly the current_profile_path_).

+           base::Bind(&GetProfileInformation, this));
+    } else {
+      BrowserThread::PostTask(
+           BrowserThread::FILE, FROM_HERE,
+           base::Bind(&StartPnaclUpdateRegistration, this));
+    }
   }
 }
+
+void PnaclComponentInstaller::ReRegisterPnacl() {
+  // No need to check the commandline flags again here.
+  // We could only have gotten here after RegisterPnaclComponent
+  // found --enable-pnacl, since that is where we create the profile_observer_,
+  // which in turn calls ReRegisterPnacl.
+  DCHECK(per_user_);
+  // Figure out profile information, before proceeding to look for files.
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&GetProfileInformation, this));
+}