android-4.0.1_r1/s

// 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/browser/extensions/extension_updater.h"

#include <algorithm>
#include <set>

#include "base/compiler_specific.h"
#include "base/logging.h"
#include "base/file_util.h"
#include "base/metrics/histogram.h"
#include "base/rand_util.h"
#include "base/stl_util-inl.h"
#include "base/string_number_conversions.h"
#include "base/string_split.h"
#include "base/string_util.h"
#include "base/time.h"
#include "base/threading/thread.h"
#include "base/version.h"
#include "crypto/sha2.h"
#include "content/common/notification_service.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/extensions/extension_error_reporter.h"
#include "chrome/browser/extensions/extension_service.h"
#include "chrome/browser/prefs/pref_service.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/utility_process_host.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/chrome_version_info.h"
#include "chrome/common/extensions/extension.h"
#include "chrome/common/extensions/extension_constants.h"
#include "chrome/common/extensions/extension_file_util.h"
#include "chrome/common/pref_names.h"
#include "googleurl/src/gurl.h"
#include "net/base/escape.h"
#include "net/base/load_flags.h"
#include "net/url_request/url_request_status.h"

#if defined(OS_MACOSX)
#include "base/sys_string_conversions.h"
#endif

#define SEND_ACTIVE_PINGS 1

using base::RandDouble;
using base::RandInt;
using base::Time;
using base::TimeDelta;
using prefs::kExtensionBlacklistUpdateVersion;
using prefs::kLastExtensionsUpdateCheck;
using prefs::kNextExtensionsUpdateCheck;

// Update AppID for extension blacklist.
const char* ExtensionUpdater::kBlacklistAppID = "com.google.crx.blacklist";

// Wait at least 5 minutes after browser startup before we do any checks. If you
// change this value, make sure to update comments where it is used.
const int kStartupWaitSeconds = 60 * 5;

// For sanity checking on update frequency - enforced in release mode only.
static const int kMinUpdateFrequencySeconds = 30;
static const int kMaxUpdateFrequencySeconds = 60 * 60 * 24 * 7;  // 7 days

// Maximum length of an extension manifest update check url, since it is a GET
// request. We want to stay under 2K because of proxies, etc.
static const int kExtensionsManifestMaxURLSize = 2000;

ManifestFetchData::ManifestFetchData(const GURL& update_url)
    : base_url_(update_url),
      full_url_(update_url) {
}

ManifestFetchData::~ManifestFetchData() {}

// The format for request parameters in update checks is:
//
//   ?x=EXT1_INFO&x=EXT2_INFO
//
// where EXT1_INFO and EXT2_INFO are url-encoded strings of the form:
//
//   id=EXTENSION_ID&v=VERSION&uc
//
// Additionally, we may include the parameter ping=PING_DATA where PING_DATA
// looks like r=DAYS or a=DAYS for extensions in the Chrome extensions gallery.
// ('r' refers to 'roll call' ie installation, and 'a' refers to 'active').
// These values will each be present at most once every 24 hours, and indicate
// the number of days since the last time it was present in an update check.
//
// So for two extensions like:
//   Extension 1- id:aaaa version:1.1
//   Extension 2- id:bbbb version:2.0
//
// the full update url would be:
//   http://somehost/path?x=id%3Daaaa%26v%3D1.1%26uc&x=id%3Dbbbb%26v%3D2.0%26uc
//
// (Note that '=' is %3D and '&' is %26 when urlencoded.)
bool ManifestFetchData::AddExtension(std::string id, std::string version,
                                     const PingData& ping_data,
                                     const std::string& update_url_data) {
  if (extension_ids_.find(id) != extension_ids_.end()) {
    NOTREACHED() << "Duplicate extension id " << id;
    return false;
  }

  // Compute the string we'd append onto the full_url_, and see if it fits.
  std::vector<std::string> parts;
  parts.push_back("id=" + id);
  parts.push_back("v=" + version);
  parts.push_back("uc");

  if (!update_url_data.empty()) {
    // Make sure the update_url_data string is escaped before using it so that
    // there is no chance of overriding the id or v other parameter value
    // we place into the x= value.
    parts.push_back("ap=" + EscapeQueryParamValue(update_url_data, true));
  }

  // Append rollcall and active ping parameters.
  if (base_url_.DomainIs("google.com")) {
    std::string ping_value;
    pings_[id] = PingData(0, 0);

    if (ping_data.rollcall_days == kNeverPinged ||
        ping_data.rollcall_days > 0) {
      ping_value += "r=" + base::IntToString(ping_data.rollcall_days);
      pings_[id].rollcall_days = ping_data.rollcall_days;
    }
#if SEND_ACTIVE_PINGS
    if (ping_data.active_days == kNeverPinged || ping_data.active_days > 0) {
      if (!ping_value.empty())
        ping_value += "&";
      ping_value += "a=" + base::IntToString(ping_data.active_days);
      pings_[id].active_days = ping_data.active_days;
    }
#endif  // SEND_ACTIVE_PINGS
    if (!ping_value.empty())
      parts.push_back("ping=" + EscapeQueryParamValue(ping_value, true));
  }

  std::string extra = full_url_.has_query() ? "&" : "?";
  extra += "x=" + EscapeQueryParamValue(JoinString(parts, '&'), true);

  // Check against our max url size, exempting the first extension added.
  int new_size = full_url_.possibly_invalid_spec().size() + extra.size();
  if (!extension_ids_.empty() && new_size > kExtensionsManifestMaxURLSize) {
    UMA_HISTOGRAM_PERCENTAGE("Extensions.UpdateCheckHitUrlSizeLimit", 1);
    return false;
  }
  UMA_HISTOGRAM_PERCENTAGE("Extensions.UpdateCheckHitUrlSizeLimit", 0);

  // We have room so go ahead and add the extension.
  extension_ids_.insert(id);
  full_url_ = GURL(full_url_.possibly_invalid_spec() + extra);
  return true;
}

bool ManifestFetchData::Includes(const std::string& extension_id) const {
  return extension_ids_.find(extension_id) != extension_ids_.end();
}

bool ManifestFetchData::DidPing(std::string extension_id, PingType type) const {
  std::map<std::string, PingData>::const_iterator i = pings_.find(extension_id);
  if (i == pings_.end())
    return false;
  int value = 0;
  if (type == ROLLCALL)
    value = i->second.rollcall_days;
  else if (type == ACTIVE)
    value = i->second.active_days;
  else
    NOTREACHED();
  return value == kNeverPinged || value > 0;
}

namespace {

// When we've computed a days value, we want to make sure we don't send a
// negative value (due to the system clock being set backwards, etc.), since -1
// is a special sentinel value that means "never pinged", and other negative
// values don't make sense.
static int SanitizeDays(int days) {
  if (days < 0)
    return 0;
  return days;
}

// Calculates the value to use for the ping days parameter.
static int CalculatePingDays(const Time& last_ping_day) {
  int days = ManifestFetchData::kNeverPinged;
  if (!last_ping_day.is_null()) {
    days = SanitizeDays((Time::Now() - last_ping_day).InDays());
  }
  return days;
}

static int CalculateActivePingDays(const Time& last_active_ping_day,
                                   bool hasActiveBit) {
  if (!hasActiveBit)
    return 0;
  if (last_active_ping_day.is_null())
    return ManifestFetchData::kNeverPinged;
  return SanitizeDays((Time::Now() - last_active_ping_day).InDays());
}

}  // namespace

ManifestFetchesBuilder::ManifestFetchesBuilder(
    ExtensionServiceInterface* service,
    ExtensionPrefs* prefs)
    : service_(service), prefs_(prefs) {
  DCHECK(service_);
  DCHECK(prefs_);
}

ManifestFetchesBuilder::~ManifestFetchesBuilder() {}

void ManifestFetchesBuilder::AddExtension(const Extension& extension) {
  // Skip extensions with empty update URLs converted from user
  // scripts.
  if (extension.converted_from_user_script() &&
      extension.update_url().is_empty()) {
    return;
  }

  // If the extension updates itself from the gallery, ignore any update URL
  // data.  At the moment there is no extra data that an extension can
  // communicate to the the gallery update servers.
  std::string update_url_data;
  if (!extension.UpdatesFromGallery())
    update_url_data = prefs_->GetUpdateUrlData(extension.id());

  AddExtensionData(extension.location(),
                   extension.id(),
                   *extension.version(),
                   extension.GetType(),
                   extension.update_url(), update_url_data);
}

void ManifestFetchesBuilder::AddPendingExtension(
    const std::string& id,
    const PendingExtensionInfo& info) {
  // Use a zero version to ensure that a pending extension will always
  // be updated, and thus installed (assuming all extensions have
  // non-zero versions).
  scoped_ptr<Version> version(
      Version::GetVersionFromString("0.0.0.0"));

  AddExtensionData(
      info.install_source(), id, *version,
      Extension::TYPE_UNKNOWN, info.update_url(), "");
}

void ManifestFetchesBuilder::ReportStats() const {
  UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckExtension",
                           url_stats_.extension_count);
  UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckTheme",
                           url_stats_.theme_count);
  UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckApp",
                           url_stats_.app_count);
  UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckPending",
                           url_stats_.pending_count);
  UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckGoogleUrl",
                           url_stats_.google_url_count);
  UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckOtherUrl",
                           url_stats_.other_url_count);
  UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckNoUrl",
                           url_stats_.no_url_count);
}

std::vector<ManifestFetchData*> ManifestFetchesBuilder::GetFetches() {
  std::vector<ManifestFetchData*> fetches;
  fetches.reserve(fetches_.size());
  for (std::multimap<GURL, ManifestFetchData*>::iterator it =
           fetches_.begin(); it != fetches_.end(); ++it) {
    fetches.push_back(it->second);
  }
  fetches_.clear();
  url_stats_ = URLStats();
  return fetches;
}

void ManifestFetchesBuilder::AddExtensionData(
    Extension::Location location,
    const std::string& id,
    const Version& version,
    Extension::Type extension_type,
    GURL update_url,
    const std::string& update_url_data) {
  if (!Extension::IsAutoUpdateableLocation(location)) {
    return;
  }

  // Skip extensions with non-empty invalid update URLs.
  if (!update_url.is_empty() && !update_url.is_valid()) {
    LOG(WARNING) << "Extension " << id << " has invalid update url "
                 << update_url;
    return;
  }

  // Skip extensions with empty IDs.
  if (id.empty()) {
    LOG(WARNING) << "Found extension with empty ID";
    return;
  }

  if (update_url.DomainIs("google.com")) {
    url_stats_.google_url_count++;
  } else if (update_url.is_empty()) {
    url_stats_.no_url_count++;
    // Fill in default update URL.
    //
    // TODO(akalin): Figure out if we should use the HTTPS version.
    update_url = Extension::GalleryUpdateUrl(false);
  } else {
    url_stats_.other_url_count++;
  }

  switch (extension_type) {
    case Extension::TYPE_THEME:
      ++url_stats_.theme_count;
      break;
    case Extension::TYPE_EXTENSION:
    case Extension::TYPE_USER_SCRIPT:
      ++url_stats_.extension_count;
      break;
    case Extension::TYPE_HOSTED_APP:
    case Extension::TYPE_PACKAGED_APP:
      ++url_stats_.app_count;
      break;
    case Extension::TYPE_UNKNOWN:
    default:
      ++url_stats_.pending_count;
      break;
  }

  DCHECK(!update_url.is_empty());
  DCHECK(update_url.is_valid());

  ManifestFetchData* fetch = NULL;
  std::multimap<GURL, ManifestFetchData*>::iterator existing_iter =
      fetches_.find(update_url);

  // Find or create a ManifestFetchData to add this extension to.
  ManifestFetchData::PingData ping_data;
  ping_data.rollcall_days = CalculatePingDays(prefs_->LastPingDay(id));
  ping_data.active_days =
      CalculateActivePingDays(prefs_->LastActivePingDay(id),
                              prefs_->GetActiveBit(id));
  while (existing_iter != fetches_.end()) {
    if (existing_iter->second->AddExtension(id, version.GetString(),
                                            ping_data, update_url_data)) {
      fetch = existing_iter->second;
      break;
    }
    existing_iter++;
  }
  if (!fetch) {
    fetch = new ManifestFetchData(update_url);
    fetches_.insert(std::pair<GURL, ManifestFetchData*>(update_url, fetch));
    bool added = fetch->AddExtension(id, version.GetString(), ping_data,
                                     update_url_data);
    DCHECK(added);
  }
}

// A utility class to do file handling on the file I/O thread.
class ExtensionUpdaterFileHandler
    : public base::RefCountedThreadSafe<ExtensionUpdaterFileHandler> {
 public:
  explicit ExtensionUpdaterFileHandler(
      base::WeakPtr<ExtensionUpdater> updater)
      : updater_(updater) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  }

  // Writes crx file data into a tempfile, and calls back the updater.
  void WriteTempFile(const std::string& extension_id, const std::string& data,
                     const GURL& download_url) {
    // Make sure we're running in the right thread.
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));

    bool failed = false;
    FilePath path;
    if (!file_util::CreateTemporaryFile(&path)) {
      LOG(WARNING) << "Failed to create temporary file path";
      failed = true;
    } else if (file_util::WriteFile(path, data.c_str(), data.length()) !=
        static_cast<int>(data.length())) {
      // TODO(asargent) - It would be nice to back off updating altogether if
      // the disk is full. (http://crbug.com/12763).
      LOG(ERROR) << "Failed to write temporary file";
      file_util::Delete(path, false);
      failed = true;
    }

    if (failed) {
      if (!BrowserThread::PostTask(
              BrowserThread::UI, FROM_HERE,
              NewRunnableMethod(
                  this, &ExtensionUpdaterFileHandler::OnCRXFileWriteError,
                  extension_id))) {
        NOTREACHED();
      }
    } else {
      if (!BrowserThread::PostTask(
              BrowserThread::UI, FROM_HERE,
              NewRunnableMethod(
                  this, &ExtensionUpdaterFileHandler::OnCRXFileWritten,
                  extension_id, path, download_url))) {
        NOTREACHED();
        // Delete |path| since we couldn't post.
        extension_file_util::DeleteFile(path, false);
      }
    }
  }

 private:
  friend class base::RefCountedThreadSafe<ExtensionUpdaterFileHandler>;

  ~ExtensionUpdaterFileHandler() {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
           BrowserThread::CurrentlyOn(BrowserThread::FILE));
  }

  void OnCRXFileWritten(const std::string& id,
                        const FilePath& path,
                        const GURL& download_url) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    if (!updater_) {
      // Delete |path| since we don't have an updater anymore.
      if (!BrowserThread::PostTask(
              BrowserThread::FILE, FROM_HERE,
              NewRunnableFunction(
                  extension_file_util::DeleteFile, path, false))) {
        NOTREACHED();
      }
      return;
    }
    // The ExtensionUpdater now owns the temp file.
    updater_->OnCRXFileWritten(id, path, download_url);
  }

  void OnCRXFileWriteError(const std::string& id) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    if (!updater_) {
      return;
    }
    updater_->OnCRXFileWriteError(id);
  }

  // Should be accessed only on UI thread.
  base::WeakPtr<ExtensionUpdater> updater_;
};

ExtensionUpdater::ExtensionFetch::ExtensionFetch()
    : id(""),
      url(),
      package_hash(""),
      version("") {}

ExtensionUpdater::ExtensionFetch::ExtensionFetch(const std::string& i,
                                                 const GURL& u,
                                                 const std::string& h,
                                                 const std::string& v)
    : id(i), url(u), package_hash(h), version(v) {}

ExtensionUpdater::ExtensionFetch::~ExtensionFetch() {}

ExtensionUpdater::ExtensionUpdater(ExtensionServiceInterface* service,
                                   ExtensionPrefs* extension_prefs,
                                   PrefService* prefs,
                                   Profile* profile,
                                   int frequency_seconds)
    : alive_(false),
      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
      service_(service), frequency_seconds_(frequency_seconds),
      method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
      will_check_soon_(false), extension_prefs_(extension_prefs),
      prefs_(prefs), profile_(profile), blacklist_checks_enabled_(true) {
  Init();
}

void ExtensionUpdater::Init() {
  DCHECK_GE(frequency_seconds_, 5);
  DCHECK(frequency_seconds_ <= kMaxUpdateFrequencySeconds);
#ifdef NDEBUG
  // In Release mode we enforce that update checks don't happen too often.
  frequency_seconds_ = std::max(frequency_seconds_, kMinUpdateFrequencySeconds);
#endif
  frequency_seconds_ = std::min(frequency_seconds_, kMaxUpdateFrequencySeconds);
}

ExtensionUpdater::~ExtensionUpdater() {
  Stop();
}

static void EnsureInt64PrefRegistered(PrefService* prefs,
                                      const char name[]) {
  if (!prefs->FindPreference(name))
    prefs->RegisterInt64Pref(name, 0);
}

static void EnsureBlacklistVersionPrefRegistered(PrefService* prefs) {
  if (!prefs->FindPreference(kExtensionBlacklistUpdateVersion))
    prefs->RegisterStringPref(kExtensionBlacklistUpdateVersion, "0");
}

// The overall goal here is to balance keeping clients up to date while
// avoiding a thundering herd against update servers.
TimeDelta ExtensionUpdater::DetermineFirstCheckDelay() {
  DCHECK(alive_);
  // If someone's testing with a quick frequency, just allow it.
  if (frequency_seconds_ < kStartupWaitSeconds)
    return TimeDelta::FromSeconds(frequency_seconds_);

  // If we've never scheduled a check before, start at frequency_seconds_.
  if (!prefs_->HasPrefPath(kNextExtensionsUpdateCheck))
    return TimeDelta::FromSeconds(frequency_seconds_);

  // If it's been a long time since our last actual check, we want to do one
  // relatively soon.
  Time now = Time::Now();
  Time last = Time::FromInternalValue(prefs_->GetInt64(
      kLastExtensionsUpdateCheck));
  int days = (now - last).InDays();
  if (days >= 30) {
    // Wait 5-10 minutes.
    return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds,
                                          kStartupWaitSeconds * 2));
  } else if (days >= 14) {
    // Wait 10-20 minutes.
    return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds * 2,
                                          kStartupWaitSeconds * 4));
  } else if (days >= 3) {
    // Wait 20-40 minutes.
    return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds * 4,
                                          kStartupWaitSeconds * 8));
  }

  // Read the persisted next check time, and use that if it isn't too soon.
  // Otherwise pick something random.
  Time saved_next = Time::FromInternalValue(prefs_->GetInt64(
      kNextExtensionsUpdateCheck));
  Time earliest = now + TimeDelta::FromSeconds(kStartupWaitSeconds);
  if (saved_next >= earliest) {
    return saved_next - now;
  } else {
    return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds,
                                          frequency_seconds_));
  }
}

void ExtensionUpdater::Start() {
  DCHECK(!alive_);
  // If these are NULL, then that means we've been called after Stop()
  // has been called.
  DCHECK(service_);
  DCHECK(extension_prefs_);
  DCHECK(prefs_);
  DCHECK(profile_);
  DCHECK(!weak_ptr_factory_.HasWeakPtrs());
  file_handler_ =
      new ExtensionUpdaterFileHandler(weak_ptr_factory_.GetWeakPtr());
  alive_ = true;
  // Make sure our prefs are registered, then schedule the first check.
  EnsureInt64PrefRegistered(prefs_, kLastExtensionsUpdateCheck);
  EnsureInt64PrefRegistered(prefs_, kNextExtensionsUpdateCheck);
  EnsureBlacklistVersionPrefRegistered(prefs_);
  ScheduleNextCheck(DetermineFirstCheckDelay());
}

void ExtensionUpdater::Stop() {
  weak_ptr_factory_.InvalidateWeakPtrs();
  alive_ = false;
  file_handler_ = NULL;
  service_ = NULL;
  extension_prefs_ = NULL;
  prefs_ = NULL;
  profile_ = NULL;
  timer_.Stop();
  will_check_soon_ = false;
  method_factory_.RevokeAll();
  manifest_fetcher_.reset();
  extension_fetcher_.reset();
  STLDeleteElements(&manifests_pending_);
  manifests_pending_.clear();
  extensions_pending_.clear();
}

void ExtensionUpdater::OnURLFetchComplete(
    const URLFetcher* source,
    const GURL& url,
    const net::URLRequestStatus& status,
    int response_code,
    const ResponseCookies& cookies,
    const std::string& data) {
  // Stop() destroys all our URLFetchers, which means we shouldn't be
  // called after Stop() is called.
  DCHECK(alive_);

  if (source == manifest_fetcher_.get()) {
    OnManifestFetchComplete(url, status, response_code, data);
  } else if (source == extension_fetcher_.get()) {
    OnCRXFetchComplete(url, status, response_code, data);
  } else {
    NOTREACHED();
  }
  NotifyIfFinished();
}

// Utility class to handle doing xml parsing in a sandboxed utility process.
class SafeManifestParser : public UtilityProcessHost::Client {
 public:
  // Takes ownership of |fetch_data|.
  SafeManifestParser(const std::string& xml, ManifestFetchData* fetch_data,
                     base::WeakPtr<ExtensionUpdater> updater)
      : xml_(xml), updater_(updater) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    fetch_data_.reset(fetch_data);
  }

  // Posts a task over to the IO loop to start the parsing of xml_ in a
  // utility process.
  void Start() {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    if (!BrowserThread::PostTask(
            BrowserThread::IO, FROM_HERE,
            NewRunnableMethod(
                this, &SafeManifestParser::ParseInSandbox,
                g_browser_process->resource_dispatcher_host()))) {
      NOTREACHED();
    }
  }

  // Creates the sandboxed utility process and tells it to start parsing.
  void ParseInSandbox(ResourceDispatcherHost* rdh) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));

    // TODO(asargent) we shouldn't need to do this branch here - instead
    // UtilityProcessHost should handle it for us. (http://crbug.com/19192)
    bool use_utility_process = rdh &&
        !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess);
    if (use_utility_process) {
      UtilityProcessHost* host = new UtilityProcessHost(
          this, BrowserThread::UI);
      host->StartUpdateManifestParse(xml_);
    } else {
      UpdateManifest manifest;
      if (manifest.Parse(xml_)) {
        if (!BrowserThread::PostTask(
                BrowserThread::UI, FROM_HERE,
                NewRunnableMethod(
                    this, &SafeManifestParser::OnParseUpdateManifestSucceeded,
                    manifest.results()))) {
          NOTREACHED();
        }
      } else {
        if (!BrowserThread::PostTask(
                BrowserThread::UI, FROM_HERE,
                NewRunnableMethod(
                    this, &SafeManifestParser::OnParseUpdateManifestFailed,
                    manifest.errors()))) {
          NOTREACHED();
        }
      }
    }
  }

  // Callback from the utility process when parsing succeeded.
  virtual void OnParseUpdateManifestSucceeded(
      const UpdateManifest::Results& results) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    if (!updater_) {
      return;
    }
    updater_->HandleManifestResults(*fetch_data_, &results);
  }

  // Callback from the utility process when parsing failed.
  virtual void OnParseUpdateManifestFailed(const std::string& error_message) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    if (!updater_) {
      return;
    }
    LOG(WARNING) << "Error parsing update manifest:\n" << error_message;
    updater_->HandleManifestResults(*fetch_data_, NULL);
  }

 private:
  ~SafeManifestParser() {
    // If we're using UtilityProcessHost, we may not be destroyed on
    // the UI or IO thread.
  }

  const std::string xml_;

  // Should be accessed only on UI thread.
  scoped_ptr<ManifestFetchData> fetch_data_;
  base::WeakPtr<ExtensionUpdater> updater_;
};


void ExtensionUpdater::OnManifestFetchComplete(
    const GURL& url,
    const net::URLRequestStatus& status,
    int response_code,
    const std::string& data) {
  // We want to try parsing the manifest, and if it indicates updates are
  // available, we want to fire off requests to fetch those updates.
  if (status.status() == net::URLRequestStatus::SUCCESS &&
      (response_code == 200 || (url.SchemeIsFile() && data.length() > 0))) {
    scoped_refptr<SafeManifestParser> safe_parser(
        new SafeManifestParser(data, current_manifest_fetch_.release(),
                               weak_ptr_factory_.GetWeakPtr()));
    safe_parser->Start();
  } else {
    // TODO(asargent) Do exponential backoff here. (http://crbug.com/12546).
    VLOG(1) << "Failed to fetch manifest '" << url.possibly_invalid_spec()
            << "' response code:" << response_code;
    RemoveFromInProgress(current_manifest_fetch_->extension_ids());
  }
  manifest_fetcher_.reset();
  current_manifest_fetch_.reset();

  // If we have any pending manifest requests, fire off the next one.
  if (!manifests_pending_.empty()) {
    ManifestFetchData* manifest_fetch = manifests_pending_.front();
    manifests_pending_.pop_front();
    StartUpdateCheck(manifest_fetch);
  }
}

void ExtensionUpdater::HandleManifestResults(
    const ManifestFetchData& fetch_data,
    const UpdateManifest::Results* results) {
  DCHECK(alive_);

  // Remove all the ids's from in_progress_ids_ (we will add them back in
  // below if they actually have updates we need to fetch and install).
  RemoveFromInProgress(fetch_data.extension_ids());

  if (!results) {
    NotifyIfFinished();
    return;
  }

  // Examine the parsed manifest and kick off fetches of any new crx files.
  std::vector<int> updates = DetermineUpdates(fetch_data, *results);
  for (size_t i = 0; i < updates.size(); i++) {
    const UpdateManifest::Result* update = &(results->list.at(updates[i]));
    const std::string& id = update->extension_id;
    in_progress_ids_.insert(id);
    if (id != std::string(kBlacklistAppID))
      NotifyUpdateFound(update->extension_id);
    FetchUpdatedExtension(update->extension_id, update->crx_url,
        update->package_hash, update->version);
  }

  // If the manifest response included a <daystart> element, we want to save
  // that value for any extensions which had sent a ping in the request.
  if (fetch_data.base_url().DomainIs("google.com") &&
      results->daystart_elapsed_seconds >= 0) {
    Time daystart =
      Time::Now() - TimeDelta::FromSeconds(results->daystart_elapsed_seconds);

    const std::set<std::string>& extension_ids = fetch_data.extension_ids();
    std::set<std::string>::const_iterator i;
    for (i = extension_ids.begin(); i != extension_ids.end(); i++) {
      if (fetch_data.DidPing(*i, ManifestFetchData::ROLLCALL)) {
        if (*i == kBlacklistAppID) {
          extension_prefs_->SetBlacklistLastPingDay(daystart);
        } else if (service_->GetExtensionById(*i, true) != NULL) {
          extension_prefs_->SetLastPingDay(*i, daystart);
        }
      }
      if (extension_prefs_->GetActiveBit(*i)) {
        extension_prefs_->SetActiveBit(*i, false);
        extension_prefs_->SetLastActivePingDay(*i, daystart);
      }
    }
  }
  NotifyIfFinished();
}

void ExtensionUpdater::ProcessBlacklist(const std::string& data) {
  DCHECK(alive_);
  // Verify sha256 hash value.
  char sha256_hash_value[crypto::SHA256_LENGTH];
  crypto::SHA256HashString(data, sha256_hash_value, crypto::SHA256_LENGTH);
  std::string hash_in_hex = base::HexEncode(sha256_hash_value,
                                            crypto::SHA256_LENGTH);

  if (current_extension_fetch_.package_hash != hash_in_hex) {
    NOTREACHED() << "Fetched blacklist checksum is not as expected. "
      << "Expected: " << current_extension_fetch_.package_hash
      << " Actual: " << hash_in_hex;
    return;
  }
  std::vector<std::string> blacklist;
  base::SplitString(data, '\n', &blacklist);

  // Tell ExtensionService to update prefs.
  service_->UpdateExtensionBlacklist(blacklist);

  // Update the pref value for blacklist version
  prefs_->SetString(kExtensionBlacklistUpdateVersion,
                    current_extension_fetch_.version);
  prefs_->ScheduleSavePersistentPrefs();
}

void ExtensionUpdater::OnCRXFetchComplete(const GURL& url,
                                          const net::URLRequestStatus& status,
                                          int response_code,
                                          const std::string& data) {
  if (status.status() == net::URLRequestStatus::SUCCESS &&
      (response_code == 200 || (url.SchemeIsFile() && data.length() > 0))) {
    if (current_extension_fetch_.id == kBlacklistAppID) {
      ProcessBlacklist(data);
      in_progress_ids_.erase(current_extension_fetch_.id);
    } else {
      // Successfully fetched - now write crx to a file so we can have the
      // ExtensionService install it.
      if (!BrowserThread::PostTask(
              BrowserThread::FILE, FROM_HERE,
              NewRunnableMethod(
                  file_handler_.get(),
                  &ExtensionUpdaterFileHandler::WriteTempFile,
                  current_extension_fetch_.id, data, url))) {
        NOTREACHED();
      }
    }
  } else {
    // TODO(asargent) do things like exponential backoff, handling
    // 503 Service Unavailable / Retry-After headers, etc. here.
    // (http://crbug.com/12546).
    VLOG(1) << "Failed to fetch extension '" << url.possibly_invalid_spec()
            << "' response code:" << response_code;
  }
  extension_fetcher_.reset();
  current_extension_fetch_ = ExtensionFetch();

  // If there are any pending downloads left, start one.
  if (!extensions_pending_.empty()) {
    ExtensionFetch next = extensions_pending_.front();
    extensions_pending_.pop_front();
    FetchUpdatedExtension(next.id, next.url, next.package_hash, next.version);
  }
}

void ExtensionUpdater::OnCRXFileWritten(const std::string& id,
                                        const FilePath& path,
                                        const GURL& download_url) {
  DCHECK(alive_);
  // The ExtensionService is now responsible for cleaning up the temp file
  // at |path|.
  service_->UpdateExtension(id, path, download_url);
  in_progress_ids_.erase(id);
  NotifyIfFinished();
}

void ExtensionUpdater::OnCRXFileWriteError(const std::string& id) {
  DCHECK(alive_);
  in_progress_ids_.erase(id);
  NotifyIfFinished();
}

void ExtensionUpdater::ScheduleNextCheck(const TimeDelta& target_delay) {
  DCHECK(alive_);
  DCHECK(!timer_.IsRunning());
  DCHECK(target_delay >= TimeDelta::FromSeconds(1));

  // Add +/- 10% random jitter.
  double delay_ms = target_delay.InMillisecondsF();
  double jitter_factor = (RandDouble() * .2) - 0.1;
  delay_ms += delay_ms * jitter_factor;
  TimeDelta actual_delay = TimeDelta::FromMilliseconds(
      static_cast<int64>(delay_ms));

  // Save the time of next check.
  Time next = Time::Now() + actual_delay;
  prefs_->SetInt64(kNextExtensionsUpdateCheck, next.ToInternalValue());
  prefs_->ScheduleSavePersistentPrefs();

  timer_.Start(actual_delay, this, &ExtensionUpdater::TimerFired);
}

void ExtensionUpdater::TimerFired() {
  DCHECK(alive_);
  CheckNow();

  // If the user has overridden the update frequency, don't bother reporting
  // this.
  if (frequency_seconds_ == ExtensionService::kDefaultUpdateFrequencySeconds) {
    Time last = Time::FromInternalValue(prefs_->GetInt64(
        kLastExtensionsUpdateCheck));
    if (last.ToInternalValue() != 0) {
      // Use counts rather than time so we can use minutes rather than millis.
      UMA_HISTOGRAM_CUSTOM_COUNTS("Extensions.UpdateCheckGap",
          (Time::Now() - last).InMinutes(),
          base::TimeDelta::FromSeconds(kStartupWaitSeconds).InMinutes(),
          base::TimeDelta::FromDays(40).InMinutes(),
          50);  // 50 buckets seems to be the default.
    }
  }

  // Save the last check time, and schedule the next check.
  int64 now = Time::Now().ToInternalValue();
  prefs_->SetInt64(kLastExtensionsUpdateCheck, now);
  ScheduleNextCheck(TimeDelta::FromSeconds(frequency_seconds_));
}

void ExtensionUpdater::CheckSoon() {
  DCHECK(alive_);
  if (will_check_soon_) {
    return;
  }
  if (BrowserThread::PostTask(
          BrowserThread::UI, FROM_HERE,
          method_factory_.NewRunnableMethod(
              &ExtensionUpdater::DoCheckSoon))) {
    will_check_soon_ = true;
  } else {
    NOTREACHED();
  }
}

bool ExtensionUpdater::WillCheckSoon() const {
  return will_check_soon_;
}

void ExtensionUpdater::DoCheckSoon() {
  DCHECK(will_check_soon_);
  CheckNow();
  will_check_soon_ = false;
}

void ExtensionUpdater::CheckNow() {
  DCHECK(alive_);
  NotifyStarted();
  ManifestFetchesBuilder fetches_builder(service_, extension_prefs_);

  const ExtensionList* extensions = service_->extensions();
  for (ExtensionList::const_iterator iter = extensions->begin();
       iter != extensions->end(); ++iter) {
    fetches_builder.AddExtension(**iter);
  }

  const PendingExtensionManager* pending_extension_manager =
      service_->pending_extension_manager();

  PendingExtensionManager::const_iterator iter;
  for (iter = pending_extension_manager->begin();
       iter != pending_extension_manager->end(); iter++) {
    // TODO(skerner): Move the determination of what gets fetched into
    // class PendingExtensionManager.
    Extension::Location location = iter->second.install_source();
    if (location != Extension::EXTERNAL_PREF &&
        location != Extension::EXTERNAL_REGISTRY)
      fetches_builder.AddPendingExtension(iter->first, iter->second);
  }

  fetches_builder.ReportStats();

  std::vector<ManifestFetchData*> fetches(fetches_builder.GetFetches());

  // Start a fetch of the blacklist if needed.
  if (blacklist_checks_enabled_) {
    // Note: it is very important that we use  the https version of the update
    // url here to avoid DNS hijacking of the blacklist, which is not validated
    // by a public key signature like .crx files are.
    ManifestFetchData* blacklist_fetch =
        new ManifestFetchData(Extension::GalleryUpdateUrl(true));
    std::string version = prefs_->GetString(kExtensionBlacklistUpdateVersion);
    ManifestFetchData::PingData ping_data;
    ping_data.rollcall_days =
        CalculatePingDays(extension_prefs_->BlacklistLastPingDay());
    blacklist_fetch->AddExtension(kBlacklistAppID, version, ping_data, "");
    StartUpdateCheck(blacklist_fetch);
  }

  // Now start fetching regular extension updates
  for (std::vector<ManifestFetchData*>::const_iterator it = fetches.begin();
       it != fetches.end(); ++it) {
    // StartUpdateCheck makes sure the url isn't already downloading or
    // scheduled, so we don't need to check before calling it. Ownership of
    // fetch is transferred here.
    StartUpdateCheck(*it);
  }
  // We don't want to use fetches after this since StartUpdateCheck()
  // takes ownership of its argument.
  fetches.clear();

  NotifyIfFinished();
}

bool ExtensionUpdater::GetExistingVersion(const std::string& id,
                                          std::string* version) {
  DCHECK(alive_);
  if (id == kBlacklistAppID) {
    *version = prefs_->GetString(kExtensionBlacklistUpdateVersion);
    return true;
  }
  const Extension* extension = service_->GetExtensionById(id, false);
  if (!extension) {
    return false;
  }
  *version = extension->version()->GetString();
  return true;
}

std::vector<int> ExtensionUpdater::DetermineUpdates(
    const ManifestFetchData& fetch_data,
    const UpdateManifest::Results& possible_updates) {
  DCHECK(alive_);
  std::vector<int> result;

  // This will only get set if one of possible_updates specifies
  // browser_min_version.
  scoped_ptr<Version> browser_version;
  PendingExtensionManager* pending_extension_manager =
      service_->pending_extension_manager();

  for (size_t i = 0; i < possible_updates.list.size(); i++) {
    const UpdateManifest::Result* update = &possible_updates.list[i];

    if (!fetch_data.Includes(update->extension_id))
      continue;

    if (!pending_extension_manager->IsIdPending(update->extension_id)) {
      // If we're not installing pending extension, and the update
      // version is the same or older than what's already installed,
      // we don't want it.
      std::string version;
      if (!GetExistingVersion(update->extension_id, &version))
        continue;

      scoped_ptr<Version> existing_version(
          Version::GetVersionFromString(version));
      scoped_ptr<Version> update_version(
          Version::GetVersionFromString(update->version));

      if (!update_version.get() ||
          update_version->CompareTo(*(existing_version.get())) <= 0) {
        continue;
      }
    }

    // If the update specifies a browser minimum version, do we qualify?
    if (update->browser_min_version.length() > 0) {
      // First determine the browser version if we haven't already.
      if (!browser_version.get()) {
        chrome::VersionInfo version_info;
        if (version_info.is_valid()) {
          browser_version.reset(Version::GetVersionFromString(
                                    version_info.Version()));
        }
      }
      scoped_ptr<Version> browser_min_version(
          Version::GetVersionFromString(update->browser_min_version));
      if (browser_version.get() && browser_min_version.get() &&
          browser_min_version->CompareTo(*browser_version.get()) > 0) {
        // TODO(asargent) - We may want this to show up in the extensions UI
        // eventually. (http://crbug.com/12547).
        LOG(WARNING) << "Updated version of extension " << update->extension_id
                     << " available, but requires chrome version "
                     << update->browser_min_version;
        continue;
      }
    }
    result.push_back(i);
  }
  return result;
}

void ExtensionUpdater::StartUpdateCheck(ManifestFetchData* fetch_data) {
  AddToInProgress(fetch_data->extension_ids());

  scoped_ptr<ManifestFetchData> scoped_fetch_data(fetch_data);
  if (CommandLine::ForCurrentProcess()->HasSwitch(
      switches::kDisableBackgroundNetworking))
    return;

  std::deque<ManifestFetchData*>::const_iterator i;
  for (i = manifests_pending_.begin(); i != manifests_pending_.end(); i++) {
    if (fetch_data->full_url() == (*i)->full_url()) {
      // This url is already scheduled to be fetched.
      return;
    }
  }

  if (manifest_fetcher_.get() != NULL) {
    if (manifest_fetcher_->url() != fetch_data->full_url()) {
      manifests_pending_.push_back(scoped_fetch_data.release());
    }
  } else {
    UMA_HISTOGRAM_COUNTS("Extensions.UpdateCheckUrlLength",
        fetch_data->full_url().possibly_invalid_spec().length());

    current_manifest_fetch_.swap(scoped_fetch_data);
    manifest_fetcher_.reset(
        URLFetcher::Create(kManifestFetcherId, fetch_data->full_url(),
                           URLFetcher::GET, this));
    manifest_fetcher_->set_request_context(
        profile_->GetRequestContext());
    manifest_fetcher_->set_load_flags(net::LOAD_DO_NOT_SEND_COOKIES |
                                      net::LOAD_DO_NOT_SAVE_COOKIES |
                                      net::LOAD_DISABLE_CACHE);
    manifest_fetcher_->Start();
  }
}

void ExtensionUpdater::FetchUpdatedExtension(const std::string& id,
                                             const GURL& url,
                                             const std::string& hash,
                                             const std::string& version) {
  for (std::deque<ExtensionFetch>::const_iterator iter =
           extensions_pending_.begin();
       iter != extensions_pending_.end(); ++iter) {
    if (iter->id == id || iter->url == url) {
      return;  // already scheduled
    }
  }

  if (extension_fetcher_.get() != NULL) {
    if (extension_fetcher_->url() != url) {
      extensions_pending_.push_back(ExtensionFetch(id, url, hash, version));
    }
  } else {
    extension_fetcher_.reset(
        URLFetcher::Create(kExtensionFetcherId, url, URLFetcher::GET, this));
    extension_fetcher_->set_request_context(
        profile_->GetRequestContext());
    extension_fetcher_->set_load_flags(net::LOAD_DO_NOT_SEND_COOKIES |
                                       net::LOAD_DO_NOT_SAVE_COOKIES |
                                       net::LOAD_DISABLE_CACHE);
    extension_fetcher_->Start();
    current_extension_fetch_ = ExtensionFetch(id, url, hash, version);
  }
}

void ExtensionUpdater::NotifyStarted() {
  NotificationService::current()->Notify(
      NotificationType::EXTENSION_UPDATING_STARTED,
      Source<Profile>(profile_),
      NotificationService::NoDetails());
}

void ExtensionUpdater::NotifyUpdateFound(const std::string& extension_id) {
  NotificationService::current()->Notify(
      NotificationType::EXTENSION_UPDATE_FOUND,
      Source<Profile>(profile_),
      Details<const std::string>(&extension_id));
}

void ExtensionUpdater::NotifyIfFinished() {
  if (in_progress_ids_.empty()) {
    NotificationService::current()->Notify(
        NotificationType::EXTENSION_UPDATING_FINISHED,
        Source<Profile>(profile_),
        NotificationService::NoDetails());
    VLOG(1) << "Sending EXTENSION_UPDATING_FINISHED";
  }
}

void ExtensionUpdater::AddToInProgress(const std::set<std::string>& ids) {
  std::set<std::string>::const_iterator i;
  for (i = ids.begin(); i != ids.end(); ++i)
    in_progress_ids_.insert(*i);
}

void ExtensionUpdater::RemoveFromInProgress(const std::set<std::string>& ids) {
  std::set<std::string>::const_iterator i;
  for (i = ids.begin(); i != ids.end(); ++i)
    in_progress_ids_.erase(*i);
}