Home | History | Annotate | Download | only in component_updater 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/bind.h"
      6 #include "base/file_util.h"
      7 #include "base/files/file_enumerator.h"
      8 #include "base/files/file_path.h"
      9 #include "base/values.h"
     10 #include "base/version.h"
     11 // TODO(ddorwin): Find a better place for ReadManifest.
     12 #include "chrome/browser/component_updater/component_unpacker.h"
     13 #include "chrome/browser/component_updater/default_component_installer.h"
     14 #include "content/public/browser/browser_thread.h"
     15 
     16 namespace component_updater {
     17 
     18 namespace {
     19 // Version "0" corresponds to no installed version. By the server's conventions,
     20 // we represent it as a dotted quad.
     21 const char kNullVersion[] = "0.0.0.0";
     22 }  // namespace
     23 
     24 ComponentInstallerTraits::~ComponentInstallerTraits() {
     25 }
     26 
     27 DefaultComponentInstaller::DefaultComponentInstaller(
     28     scoped_ptr<ComponentInstallerTraits> installer_traits)
     29     : current_version_(kNullVersion) {
     30   installer_traits_ = installer_traits.Pass();
     31 }
     32 
     33 DefaultComponentInstaller::~DefaultComponentInstaller() {
     34 }
     35 
     36 void DefaultComponentInstaller::Register(ComponentUpdateService* cus) {
     37   if (!installer_traits_) {
     38     NOTREACHED() << "A DefaultComponentInstaller has been created but "
     39                  << "has no installer traits.";
     40     return;
     41   }
     42   content::BrowserThread::PostBlockingPoolTask(
     43       FROM_HERE,
     44       base::Bind(&DefaultComponentInstaller::StartRegistration,
     45                  base::Unretained(this),
     46                  cus));
     47 }
     48 
     49 void DefaultComponentInstaller::OnUpdateError(int error) {
     50   NOTREACHED() << "Component update error: " << error;
     51 }
     52 
     53 bool DefaultComponentInstaller::InstallHelper(
     54     const base::DictionaryValue& manifest,
     55     const base::FilePath& unpack_path,
     56     const base::FilePath& install_path) {
     57   if (!base::Move(unpack_path, install_path))
     58     return false;
     59   if (!installer_traits_->OnCustomInstall(manifest, install_path))
     60     return false;
     61   if (!installer_traits_->VerifyInstallation(install_path))
     62     return false;
     63   return true;
     64 }
     65 
     66 bool DefaultComponentInstaller::Install(const base::DictionaryValue& manifest,
     67                                         const base::FilePath& unpack_path) {
     68   std::string manifest_version;
     69   manifest.GetStringASCII("version", &manifest_version);
     70   base::Version version(manifest_version.c_str());
     71   if (!version.IsValid())
     72     return false;
     73   if (current_version_.CompareTo(version) > 0)
     74     return false;
     75   base::FilePath install_path =
     76       installer_traits_->GetBaseDirectory().AppendASCII(version.GetString());
     77   if (base::PathExists(install_path)) {
     78     if (!base::DeleteFile(install_path, true))
     79       return false;
     80   }
     81   if (!InstallHelper(manifest, unpack_path, install_path)) {
     82     base::DeleteFile(install_path, true);
     83     return false;
     84   }
     85   current_version_ = version;
     86   // TODO(ddorwin): Change the parameter to scoped_ptr<base::DictionaryValue>
     87   // so we can avoid this DeepCopy.
     88   current_manifest_.reset(manifest.DeepCopy());
     89   scoped_ptr<base::DictionaryValue> manifest_copy(
     90       current_manifest_->DeepCopy());
     91   content::BrowserThread::PostTask(
     92       content::BrowserThread::UI,
     93       FROM_HERE,
     94       base::Bind(&ComponentInstallerTraits::ComponentReady,
     95                  base::Unretained(installer_traits_.get()),
     96                  current_version_,
     97                  GetInstallDirectory(),
     98                  base::Passed(&manifest_copy)));
     99   return true;
    100 }
    101 
    102 bool DefaultComponentInstaller::GetInstalledFile(
    103     const std::string& file,
    104     base::FilePath* installed_file) {
    105   if (current_version_.Equals(base::Version(kNullVersion)))
    106     return false;  // No component has been installed yet.
    107 
    108   *installed_file = installer_traits_->GetBaseDirectory()
    109                         .AppendASCII(current_version_.GetString())
    110                         .AppendASCII(file);
    111   return true;
    112 }
    113 
    114 void DefaultComponentInstaller::StartRegistration(ComponentUpdateService* cus) {
    115   base::FilePath base_dir = installer_traits_->GetBaseDirectory();
    116   if (!base::PathExists(base_dir) && !base::CreateDirectory(base_dir)) {
    117     NOTREACHED() << "Could not create the base directory for "
    118                  << installer_traits_->GetName() << " ("
    119                  << base_dir.MaybeAsASCII() << ").";
    120     return;
    121   }
    122 
    123   base::FilePath latest_dir;
    124   base::Version latest_version(kNullVersion);
    125   std::vector<base::FilePath> older_dirs;
    126   bool found = false;
    127   base::FileEnumerator file_enumerator(
    128       base_dir, false, base::FileEnumerator::DIRECTORIES);
    129   for (base::FilePath path = file_enumerator.Next();
    130        !path.value().empty();
    131        path = file_enumerator.Next()) {
    132     base::Version version(path.BaseName().MaybeAsASCII());
    133     // Ignore folders that don't have valid version names. These folders are not
    134     // managed by component installer so do not try to remove them.
    135     if (!version.IsValid())
    136       continue;
    137     if (!installer_traits_->VerifyInstallation(path)) {
    138       older_dirs.push_back(path);
    139       continue;
    140     }
    141     if (found) {
    142       if (version.CompareTo(latest_version) > 0) {
    143         older_dirs.push_back(latest_dir);
    144         latest_dir = path;
    145         latest_version = version;
    146       } else {
    147         older_dirs.push_back(path);
    148       }
    149     } else {
    150       latest_dir = path;
    151       latest_version = version;
    152       found = true;
    153     }
    154   }
    155 
    156   if (found) {
    157     current_manifest_ = ReadManifest(latest_dir);
    158     if (current_manifest_) {
    159       current_version_ = latest_version;
    160       // TODO(ddorwin): Remove these members and pass them directly to
    161       // FinishRegistration().
    162       base::ReadFileToString(latest_dir.AppendASCII("manifest.fingerprint"),
    163                              &current_fingerprint_);
    164     } else {
    165       // If the manifest can't be read, mark the directory for deletion and
    166       // continue as if there were no versioned directories at all.
    167       DLOG(ERROR) << "Failed to read manifest for "
    168                   << installer_traits_->GetName() << " ("
    169                   << base_dir.MaybeAsASCII() << ").";
    170       older_dirs.push_back(latest_dir);
    171     }
    172   }
    173 
    174   // Remove older versions of the component. None should be in use during
    175   // browser startup.
    176   for (std::vector<base::FilePath>::iterator iter = older_dirs.begin();
    177        iter != older_dirs.end();
    178        ++iter) {
    179     base::DeleteFile(*iter, true);
    180   }
    181 
    182   content::BrowserThread::PostTask(
    183       content::BrowserThread::UI,
    184       FROM_HERE,
    185       base::Bind(&DefaultComponentInstaller::FinishRegistration,
    186                  base::Unretained(this),
    187                  cus));
    188 }
    189 
    190 base::FilePath DefaultComponentInstaller::GetInstallDirectory() {
    191   return installer_traits_->GetBaseDirectory()
    192       .AppendASCII(current_version_.GetString());
    193 }
    194 
    195 void DefaultComponentInstaller::FinishRegistration(
    196     ComponentUpdateService* cus) {
    197   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    198   if (installer_traits_->CanAutoUpdate()) {
    199     CrxComponent crx;
    200     crx.name = installer_traits_->GetName();
    201     crx.installer = this;
    202     crx.version = current_version_;
    203     crx.fingerprint = current_fingerprint_;
    204     installer_traits_->GetHash(&crx.pk_hash);
    205     ComponentUpdateService::Status status = cus->RegisterComponent(crx);
    206     if (status != ComponentUpdateService::kOk &&
    207         status != ComponentUpdateService::kReplaced) {
    208       NOTREACHED() << "Component registration failed for "
    209                    << installer_traits_->GetName();
    210       return;
    211     }
    212   }
    213 
    214   if (current_version_.CompareTo(base::Version(kNullVersion)) > 0) {
    215     scoped_ptr<base::DictionaryValue> manifest_copy(
    216         current_manifest_->DeepCopy());
    217     installer_traits_->ComponentReady(
    218         current_version_, GetInstallDirectory(), manifest_copy.Pass());
    219   }
    220 }
    221 
    222 }  // namespace component_updater
    223