chrome/test/mini_installer_test/installer_path_provider.cc

   1 // Copyright (c) 2012 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 "chrome/test/mini_installer_test/installer_path_provider.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/command_line.h"
  10 #include "base/file_util.h"
  11 #include "base/files/file_enumerator.h"
  12 #include "base/path_service.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "chrome/test/mini_installer_test/installer_test_util.h"
  16 #include "chrome/test/mini_installer_test/mini_installer_test_constants.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace {
  20
  21 struct FilePathInfo {
  22   base::FileEnumerator::FileInfo info;
  23   base::FilePath path;
  24 };
  25
  26 bool CompareDate(const FilePathInfo& a, const FilePathInfo& b) {
  27   return a.info.GetLastModifiedTime() > b.info.GetLastModifiedTime();
  28 }
  29
  30 // Get list of file |type| matching |pattern| in |root|.
  31 // The list is sorted in last modified date order.
  32 // Return true if files/directories are found.
  33 bool FindMatchingFiles(const base::FilePath& root,
  34                        const std::string& pattern,
  35                        base::FileEnumerator::FileType type,
  36                        std::vector<base::FilePath>* paths) {
  37   base::FileEnumerator files(root, false, type,
  38       base::FilePath().AppendASCII(pattern).value());
  39   std::vector<FilePathInfo> matches;
  40   for (base::FilePath current = files.Next(); !current.empty();
  41       current = files.Next()) {
  42     FilePathInfo entry;
  43     entry.info = files.GetInfo();
  44     entry.path = current;
  45     matches.push_back(entry);
  46   }
  47
  48   if (matches.empty())
  49     return false;
  50
  51   std::sort(matches.begin(), matches.end(), CompareDate);
  52   std::vector<FilePathInfo>::iterator current;
  53   for (current = matches.begin(); current != matches.end(); ++current) {
  54     paths->push_back(current->path);
  55   }
  56   return true;
  57 }
  58
  59 bool FindNewestMatchingFile(const base::FilePath& root,
  60                             const std::string& pattern,
  61                             base::FileEnumerator::FileType type,
  62                             base::FilePath* path) {
  63   std::vector<base::FilePath> paths;
  64   if (FindMatchingFiles(root, pattern, type, &paths)) {
  65     *path = paths[0];
  66     return true;
  67   }
  68   return false;
  69 }
  70
  71 }  // namespace
  72
  73 namespace installer_test {
  74
  75 InstallerPathProvider::InstallerPathProvider() {
  76   base::FilePath full_installer, previous_installer;
  77   if (!GetFullInstaller(&full_installer) ||
  78       !GetPreviousInstaller(&previous_installer))
  79     return;
  80   current_build_ =
  81       full_installer.DirName().DirName().BaseName().MaybeAsASCII();
  82   previous_build_ =
  83       previous_installer.DirName().DirName().BaseName().MaybeAsASCII();
  84 }
  85
  86 InstallerPathProvider::InstallerPathProvider(
  87     const std::string& build_under_test) : current_build_(build_under_test) {
  88   base::FilePath full_installer, previous_installer;
  89   if (!GetFullInstaller(&full_installer) ||
  90       !GetPreviousInstaller(&previous_installer))
  91     return;
  92   previous_build_ =
  93       previous_installer.DirName().DirName().BaseName().MaybeAsASCII();
  94 }
  95
  96 InstallerPathProvider::~InstallerPathProvider() {}
  97
  98 bool InstallerPathProvider::GetFullInstaller(base::FilePath* path) {
  99   std::string full_installer_pattern("*_chrome_installer*");
 100   return GetInstaller(full_installer_pattern, path);
 101 }
 102
 103 bool InstallerPathProvider::GetDiffInstaller(base::FilePath* path) {
 104   std::string diff_installer_pattern("*_from_*");
 105   return GetInstaller(diff_installer_pattern, path);
 106 }
 107
 108 bool InstallerPathProvider::GetMiniInstaller(base::FilePath* path) {
 109   // Use local copy of installer, else fall back to filer.
 110   base::FilePath mini_installer = PathFromExeDir(
 111       mini_installer_constants::kChromeMiniInstallerExecutable);
 112   if (base::PathExists(mini_installer)) {
 113     *path = mini_installer;
 114     return true;
 115   }
 116   std::string mini_installer_pattern("mini_installer.exe");
 117   return GetInstaller(mini_installer_pattern, path);
 118 }
 119
 120 bool InstallerPathProvider::GetPreviousInstaller(base::FilePath* path) {
 121   std::string diff_installer_pattern("*_from_*");
 122   std::string full_installer_pattern("*_chrome_installer*");
 123   base::FilePath diff_installer;
 124   if (!GetInstaller(diff_installer_pattern, &diff_installer))
 125     return false;
 126
 127   base::FilePath previous_installer;
 128   std::vector<std::string> tokenized_name;
 129   Tokenize(diff_installer.BaseName().MaybeAsASCII(),
 130       "_", &tokenized_name);
 131   std::string build_pattern = base::StringPrintf(
 132       "*%s", tokenized_name[2].c_str());
 133   std::vector<base::FilePath> previous_build;
 134   if (FindMatchingFiles(diff_installer.DirName().DirName().DirName(),
 135       build_pattern, base::FileEnumerator::DIRECTORIES,
 136       &previous_build)) {
 137     base::FilePath windir = previous_build.at(0).Append(
 138         mini_installer_constants::kWinFolder);
 139     FindNewestMatchingFile(windir, full_installer_pattern,
 140         base::FileEnumerator::FILES, &previous_installer);
 141   }
 142
 143   if (previous_installer.empty())
 144     return false;
 145   *path = previous_installer;
 146   return true;
 147 }
 148
 149 bool InstallerPathProvider::GetStandaloneInstaller(base::FilePath* path) {
 150   // Get standalone installer.
 151   base::FilePath standalone_installer(
 152       mini_installer_constants::kChromeStandAloneInstallerLocation);
 153   // Get the file name.
 154   std::vector<std::string> tokenized_build_number;
 155   if (current_build_.empty())
 156     return false;
 157   Tokenize(current_build_, ".", &tokenized_build_number);
 158   std::string standalone_installer_filename = base::StringPrintf(
 159       "%s%s_%s.exe",
 160       base::FilePath(mini_installer_constants::kUntaggedInstallerPattern)
 161           .MaybeAsASCII().c_str(),
 162       tokenized_build_number[2].c_str(),
 163       tokenized_build_number[3].c_str());
 164   standalone_installer = standalone_installer.AppendASCII(current_build_)
 165       .Append(mini_installer_constants::kWinFolder)
 166       .AppendASCII(standalone_installer_filename);
 167   *path = standalone_installer;
 168   return base::PathExists(standalone_installer);
 169 }
 170
 171 bool InstallerPathProvider::GetSignedStandaloneInstaller(base::FilePath* path) {
 172   base::FilePath standalone_installer;
 173   if (!GetStandaloneInstaller(&standalone_installer))
 174     return false;
 175   base::FilePath tagged_installer = PathFromExeDir(
 176       mini_installer_constants::kStandaloneInstaller);
 177   CommandLine sign_command = CommandLine::FromString(
 178       base::StringPrintf(L"%ls %ls %ls %ls",
 179       mini_installer_constants::kChromeApplyTagExe,
 180       standalone_installer.value().c_str(),
 181       tagged_installer.value().c_str(),
 182       mini_installer_constants::kChromeApplyTagParameters));
 183
 184   if (!installer_test::RunAndWaitForCommandToFinish(sign_command))
 185     return false;
 186
 187   *path = PathFromExeDir(mini_installer_constants::kStandaloneInstaller);
 188   return true;
 189 }
 190
 191 base::FilePath InstallerPathProvider::PathFromExeDir(
 192     const base::FilePath::StringType& name) {
 193   base::FilePath path;
 194   PathService::Get(base::DIR_EXE, &path);
 195   path = path.Append(name);
 196   return path;
 197 }
 198
 199 bool InstallerPathProvider::GetInstaller(const std::string& pattern,
 200                                          base::FilePath* path) {
 201   base::FilePath installer;
 202   // Search filer for installer binary.
 203   base::FilePath root(mini_installer_constants::kChromeInstallersLocation);
 204   std::vector<base::FilePath> paths;
 205   if (!FindMatchingFiles(root, current_build_,
 206                          base::FileEnumerator::DIRECTORIES, &paths)) {
 207     return false;
 208   }
 209
 210   std::vector<base::FilePath>::const_iterator dir;
 211   for (dir = paths.begin(); dir != paths.end(); ++dir) {
 212     base::FilePath windir = dir->Append(
 213         mini_installer_constants::kWinFolder);
 214     if (FindNewestMatchingFile(windir, pattern, base::FileEnumerator::FILES,
 215                                &installer)) {
 216       break;
 217     }
 218   }
 219
 220   if (installer.empty()) {
 221     LOG(WARNING) << "Failed to find installer with pattern: " << pattern;
 222     return false;
 223   }
 224
 225   *path = installer;
 226   return true;
 227 }
 228
 229 std::string InstallerPathProvider::GetCurrentBuild() {
 230   return current_build_;
 231 }
 232
 233 std::string InstallerPathProvider::GetPreviousBuild() {
 234   return previous_build_;
 235 }
 236
 237 }  // namespace