Implement support in DefaultComponentInstaller for picking up bundled

components/component_updater/default_component_installer.cc

 // Copyright 2014 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 "components/component_updater/default_component_installer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
+#include "base/path_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "base/version.h"
+#include "components/component_updater/component_updater_paths.h"
 // TODO(ddorwin): Find a better place for ReadManifest.
 #include "components/component_updater/component_updater_service.h"
 #include "components/update_client/component_unpacker.h"
 #include "components/update_client/utils.h"
 
 using update_client::CrxComponent;
 
 namespace component_updater {
 
 namespace {
@@ skipping 69 matching lines @@
   manifest.GetStringASCII("version", &manifest_version);
   base::Version version(manifest_version);
 
   VLOG(1) << "Install: version=" << version.GetString()
           << " current version=" << current_version_.GetString();
 
   if (!version.IsValid())
     return false;
   if (current_version_.CompareTo(version) > 0)
     return false;
-  base::FilePath install_path =
-      installer_traits_->GetBaseDirectory().AppendASCII(version.GetString());
+  base::FilePath install_path;
+  if (!PathService::Get(DIR_COMPONENT_USER, &install_path))
+    return false;
+  install_path = install_path.Append(installer_traits_->GetRelativeInstallDir())
+                     .AppendASCII(version.GetString());
   if (base::PathExists(install_path)) {
     if (!base::DeleteFile(install_path, true))
       return false;
   }
   if (!InstallHelper(manifest, unpack_path, install_path)) {
     base::DeleteFile(install_path, true);
     return false;
   }
   current_version_ = version;
+  current_install_dir_ = install_path;
   // TODO(ddorwin): Change parameter to std::unique_ptr<base::DictionaryValue>
   // so we can avoid this DeepCopy.
   current_manifest_.reset(manifest.DeepCopy());
   std::unique_ptr<base::DictionaryValue> manifest_copy(
       current_manifest_->DeepCopy());
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DefaultComponentInstaller::ComponentReady,
                  this, base::Passed(&manifest_copy)));
   return true;
 }
 
 bool DefaultComponentInstaller::GetInstalledFile(
     const std::string& file,
     base::FilePath* installed_file) {
   if (current_version_ == base::Version(kNullVersion))
     return false;  // No component has been installed yet.
-
-  *installed_file = installer_traits_->GetBaseDirectory()
-                        .AppendASCII(current_version_.GetString())
-                        .AppendASCII(file);
+  *installed_file = current_install_dir_.AppendASCII(file);
   return true;
 }
 
 bool DefaultComponentInstaller::Uninstall() {
   DCHECK(thread_checker_.CalledOnValidThread());
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DefaultComponentInstaller::UninstallOnTaskRunner, this));
   return true;
 }
 
+bool DefaultComponentInstaller::FindPreinstallation() {
+  base::FilePath path;
+  if (!PathService::Get(DIR_COMPONENT_PREINSTALLED, &path))
+    return false;
+  path = path.Append(installer_traits_->GetRelativeInstallDir());
+  if (!base::PathExists(path))
+    return false;
+  std::unique_ptr<base::DictionaryValue> manifest =
+      update_client::ReadManifest(path);
+  if (!manifest || !installer_traits_->VerifyInstallation(*manifest, path))
+    return false;
+  std::string version_lexical;
+  if (!manifest->GetStringASCII("version", &version_lexical))
+    return false;
+  const base::Version version(version_lexical);
+  if (!version.IsValid())
+    return false;
+  current_install_dir_ = path;
+  current_manifest_ = std::move(manifest);
+  current_version_ = version;
+  return true;
+}
+
 void DefaultComponentInstaller::StartRegistration(ComponentUpdateService* cus) {
   DCHECK(task_runner_.get());
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
-  base::FilePath base_dir = installer_traits_->GetBaseDirectory();
+
+  base::Version latest_version(kNullVersion);
+
+  // First check for an installation set up alongside Chrome itself.
+  if (FindPreinstallation())
+    latest_version = current_version_;
+
+  // Then check for a higher-versioned user-wide installation.
+  base::FilePath latest_path;
+  std::unique_ptr<base::DictionaryValue> latest_manifest;
+  base::FilePath base_dir;
+  if (!PathService::Get(DIR_COMPONENT_USER, &base_dir))
+    return;
+  base_dir = base_dir.Append(installer_traits_->GetRelativeInstallDir());
   if (!base::PathExists(base_dir) && !base::CreateDirectory(base_dir)) {
     PLOG(ERROR) << "Could not create the base directory for "
                 << installer_traits_->GetName() << " ("
                 << base_dir.MaybeAsASCII() << ").";
     return;
   }
-
-  base::FilePath latest_path;
-  base::Version latest_version(kNullVersion);
-  std::unique_ptr<base::DictionaryValue> latest_manifest;
-
   std::vector<base::FilePath> older_paths;
   base::FileEnumerator file_enumerator(
       base_dir, false, base::FileEnumerator::DIRECTORIES);
   for (base::FilePath path = file_enumerator.Next();
        !path.value().empty();
        path = file_enumerator.Next()) {
     base::Version version(path.BaseName().MaybeAsASCII());
 
     // Ignore folders that don't have valid version names. These folders are not
     // managed by component installer so do not try to remove them.
@@ skipping 12 matching lines @@
     if (!manifest || !installer_traits_->VerifyInstallation(*manifest, path)) {
       PLOG(ERROR) << "Failed to read manifest or verify installation for "
                   << installer_traits_->GetName() << " (" << path.MaybeAsASCII()
                   << ").";
       older_paths.push_back(path);
       continue;
     }
 
     // New valid |version| folder found!
 
-    if (latest_manifest) {
-      DCHECK(!latest_path.empty());
+    if (!latest_path.empty())
       older_paths.push_back(latest_path);
-    }
 
     latest_path = path;
     latest_version = version;
     latest_manifest = std::move(manifest);
   }
 
   if (latest_manifest) {
     current_version_ = latest_version;
     current_manifest_ = std::move(latest_manifest);
+    current_install_dir_ = latest_path;
     // TODO(ddorwin): Remove these members and pass them directly to
     // FinishRegistration().
     base::ReadFileToString(latest_path.AppendASCII("manifest.fingerprint"),
                            &current_fingerprint_);
   }
 
   // Remove older versions of the component. None should be in use during
   // browser startup.
   for (const auto& older_path : older_paths)
     base::DeleteFile(older_path, true);
 }
 
 void DefaultComponentInstaller::UninstallOnTaskRunner() {
   DCHECK(task_runner_.get());
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
-  const base::FilePath base_dir = installer_traits_->GetBaseDirectory();
 
+  // Only try to delete any files that are in our user-level install path.
+  base::FilePath userInstallPath;
+  if (!PathService::Get(DIR_COMPONENT_USER, &userInstallPath))
+    return;
+  if (!userInstallPath.IsParent(current_install_dir_))
+    return;
+
+  const base::FilePath base_dir = current_install_dir_.DirName();
   base::FileEnumerator file_enumerator(base_dir, false,
                                        base::FileEnumerator::DIRECTORIES);
   for (base::FilePath path = file_enumerator.Next(); !path.value().empty();
        path = file_enumerator.Next()) {
     base::Version version(path.BaseName().MaybeAsASCII());
 
     // Ignore folders that don't have valid version names. These folders are not
     // managed by the component installer, so do not try to remove them.
     if (!version.IsValid())
       continue;
 
     if (!base::DeleteFile(path, true))
       DLOG(ERROR) << "Couldn't delete " << path.value();
   }
 
   // Delete the base directory if it's empty now.
   if (base::IsDirectoryEmpty(base_dir)) {
     if (base::DeleteFile(base_dir, false))
       DLOG(ERROR) << "Couldn't delete " << base_dir.value();
   }
 }
 
-base::FilePath DefaultComponentInstaller::GetInstallDirectory() {
-  return installer_traits_->GetBaseDirectory()
-      .AppendASCII(current_version_.GetString());
-}
-
 void DefaultComponentInstaller::FinishRegistration(
     ComponentUpdateService* cus,
     const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (installer_traits_->CanAutoUpdate()) {
     CrxComponent crx;
     crx.name = installer_traits_->GetName();
     crx.requires_network_encryption =
         installer_traits_->RequiresNetworkEncryption();
     crx.installer = this;
@@ skipping 14 matching lines @@
     return;
 
   std::unique_ptr<base::DictionaryValue> manifest_copy(
       current_manifest_->DeepCopy());
   ComponentReady(std::move(manifest_copy));
 }
 
 void DefaultComponentInstaller::ComponentReady(
     std::unique_ptr<base::DictionaryValue> manifest) {
   VLOG(1) << "Component ready, version " << current_version_.GetString()
-          << " in " << GetInstallDirectory().value();
-  installer_traits_->ComponentReady(current_version_, GetInstallDirectory(),
+          << " in " << current_install_dir_.value();
+  installer_traits_->ComponentReady(current_version_, current_install_dir_,
                                     std::move(manifest));
 }
 
 }  // namespace component_updater