Enforce the 'requirements' field in manifests.

chrome/browser/extensions/updater/extension_downloader.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/extensions/updater/extension_downloader.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 17 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
+using extensions::ManifestFetchData;
 
 namespace extensions {
 
 const char ExtensionDownloader::kBlacklistAppID[] = "com.google.crx.blacklist";
 
 namespace {
 
 const char kNotFromWebstoreInstallSource[] = "notfromwebstore";
 const char kDefaultInstallSource[] = "";
 
@@ skipping 51 matching lines @@
         base::Bind(&CheckThatCRXIsReadable, crx_path));
   }
 }
 
 }  // namespace
 
 ExtensionDownloader::ExtensionFetch::ExtensionFetch()
     : id(""),
       url(),
       package_hash(""),
-      version("") {}
+      version(""),
+      is_sync(false) {}
 
 ExtensionDownloader::ExtensionFetch::ExtensionFetch(
     const std::string& id,
     const GURL& url,
     const std::string& package_hash,
-    const std::string& version)
-    : id(id), url(url), package_hash(package_hash), version(version) {}
+    const std::string& version,
+    const bool is_sync)
+    : id(id), url(url), package_hash(package_hash), version(version),
+      is_sync(is_sync) {}
 
 ExtensionDownloader::ExtensionFetch::~ExtensionFetch() {}
 
 ExtensionDownloader::ExtensionDownloader(
     ExtensionDownloaderDelegate* delegate,
     net::URLRequestContextGetter* request_context)
     : delegate_(delegate),
       request_context_(request_context),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(delegate_);
@@ skipping 18 matching lines @@
 
   // 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 = delegate_->GetUpdateUrlData(extension.id());
 
   return AddExtensionData(extension.id(), *extension.version(),
                           extension.GetType(), extension.update_url(),
-                          update_url_data);
+                          update_url_data, false);
 }
 
 bool ExtensionDownloader::AddPendingExtension(const std::string& id,
-                                              const GURL& update_url) {
+                                              const GURL& update_url,
+                                              bool is_sync) {
   // Use a zero version to ensure that a pending extension will always
   // be updated, and thus installed (assuming all extensions have
   // non-zero versions).
   Version version("0.0.0.0");
   DCHECK(version.IsValid());
 
-  return AddExtensionData(id, version, Extension::TYPE_UNKNOWN, update_url, "");
+  return AddExtensionData(id, version, Extension::TYPE_UNKNOWN, update_url, "",
+                          is_sync);
 }
 
 void ExtensionDownloader::StartAllPending() {
   ReportStats();
   url_stats_ = URLStats();
 
   for (FetchMap::iterator it = fetches_preparing_.begin();
        it != fetches_preparing_.end(); ++it) {
     const std::vector<ManifestFetchData*>& list = it->second;
     for (size_t i = 0; i < list.size(); ++i) {
       StartUpdateCheck(list[i]);
     }
   }
   fetches_preparing_.clear();
 }
 
 void ExtensionDownloader::StartBlacklistUpdate(
-    const std::string& version,
-   const ManifestFetchData::PingData& ping_data) {
+    const std::string& version, const ManifestFetchData::PingData& ping_data) {
   // 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_urls::GetWebstoreUpdateUrl(true));
   blacklist_fetch->AddExtension(kBlacklistAppID, version, &ping_data, "",
-                                kDefaultInstallSource);
+                                kDefaultInstallSource, false /* is_sync */);
   StartUpdateCheck(blacklist_fetch);
 }
 
 bool ExtensionDownloader::AddExtensionData(const std::string& id,
                                            const Version& version,
                                            Extension::Type extension_type,
                                            GURL update_url,
-                                           const std::string& update_url_data) {
+                                           const std::string& update_url_data,
+                                           bool is_sync) {
   // 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 false;
   }
 
   // Skip extensions with empty IDs.
   if (id.empty()) {
     LOG(WARNING) << "Found extension with empty ID";
@@ skipping 53 matching lines @@
 
     // Find or create a ManifestFetchData to add this extension to.
     ManifestFetchData* fetch = NULL;
     FetchMap::iterator existing_iter = fetches_preparing_.find(update_urls[i]);
     if (existing_iter != fetches_preparing_.end() &&
         !existing_iter->second.empty()) {
       // Try to add to the ManifestFetchData at the end of the list.
       ManifestFetchData* existing_fetch = existing_iter->second.back();
       if (existing_fetch->AddExtension(id, version.GetString(),
                                        optional_ping_data, update_url_data,
-                                       install_source)) {
+                                       install_source, is_sync)) {
         fetch = existing_fetch;
       }
     }
     if (!fetch) {
       // Otherwise add a new element to the list, if the list doesn't exist or
       // if its last element is already full.
       fetch = new ManifestFetchData(update_urls[i]);
       fetches_preparing_[update_urls[i]].push_back(fetch);
       bool added = fetch->AddExtension(id, version.GetString(),
                                        optional_ping_data,
                                        update_url_data,
-                                       install_source);
+                                       install_source,
+                                       is_sync);
       DCHECK(added);
     }
   }
 
   return true;
 }
 
 void ExtensionDownloader::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);
 }
 
 void ExtensionDownloader::StartUpdateCheck(ManifestFetchData* fetch_data) {
   scoped_ptr<ManifestFetchData> scoped_fetch_data(fetch_data);
-  const std::set<std::string>& id_set(fetch_data->extension_ids());
+  const ManifestFetchData::ExtensionInfoMap& id_map(
+      fetch_data->extension_infos());
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableBackgroundNetworking)) {
-    NotifyExtensionsDownloadFailed(id_set,
+    NotifyExtensionsDownloadFailed(id_map,
                                    ExtensionDownloaderDelegate::DISABLED);
     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_->GetURL() != 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());
 
     if (VLOG_IS_ON(2)) {
-      std::vector<std::string> id_vector(id_set.begin(), id_set.end());
+      std::vector<std::string> id_vector;
+      ManifestFetchData::ExtensionInfoMap::const_iterator it;
+      for (it = id_map.begin(); it != id_map.end(); ++it)
+        id_vector.push_back(it->first);
       std::string id_list = JoinString(id_vector, ',');
-      VLOG(2) << "Fetching " << fetch_data->full_url() << " for "
-              << id_list;
+      VLOG(2) << "Fetching " << fetch_data->full_url() << " for " << id_list;
     }
 
     current_manifest_fetch_.swap(scoped_fetch_data);
     manifest_fetcher_.reset(net::URLFetcher::Create(
         kManifestFetcherId, fetch_data->full_url(), net::URLFetcher::GET,
         this));
     manifest_fetcher_->SetRequestContext(request_context_);
     manifest_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                                     net::LOAD_DO_NOT_SAVE_COOKIES |
                                     net::LOAD_DISABLE_CACHE);
@@ skipping 37 matching lines @@
             data,
             current_manifest_fetch_.release(),
             base::Bind(&ExtensionDownloader::HandleManifestResults,
                        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;
     NotifyExtensionsDownloadFailed(
-        current_manifest_fetch_->extension_ids(),
+        current_manifest_fetch_->extension_infos(),
         ExtensionDownloaderDelegate::MANIFEST_FETCH_FAILED);
   }
   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 ExtensionDownloader::HandleManifestResults(
     const ManifestFetchData& fetch_data,
     const UpdateManifest::Results* results) {
   // Keep a list of extensions that will not be updated, so that the |delegate_|
   // can be notified once we're done here.
-  std::set<std::string> not_updated(fetch_data.extension_ids());
+  ManifestFetchData::ExtensionInfoMap not_updated(fetch_data.extension_infos());
 
   if (!results) {
     NotifyExtensionsDownloadFailed(
         not_updated,
         ExtensionDownloaderDelegate::MANIFEST_INVALID);
     return;
   }
 
   // Examine the parsed manifest and kick off fetches of any new crx files.
   std::vector<int> updates;
   DetermineUpdates(fetch_data, *results, &updates);
   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;
+    bool is_sync = not_updated[id].is_sync;
     not_updated.erase(id);
     if (id != kBlacklistAppID) {
       NotifyUpdateFound(update->extension_id);
     } else {
       // The URL of the blacklist file is returned by the server and we need to
       // be sure that we continue to be able to reliably detect whether a URL
       // references a blacklist file.
       DCHECK(extension_urls::IsBlacklistUpdateUrl(update->crx_url))
           << update->crx_url;
     }
     FetchUpdatedExtension(update->extension_id, update->crx_url,
-                          update->package_hash, update->version);
+                          update->package_hash, update->version,
+                          is_sync);
   }
 
   // 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 day_start =
         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;
+    const ManifestFetchData::ExtensionInfoMap& extension_ids =
+        fetch_data.extension_infos();
+    ManifestFetchData::ExtensionInfoMap::const_iterator i;
     for (i = extension_ids.begin(); i != extension_ids.end(); i++) {
-      const std::string& id = *i;
+      const std::string& id = i->first;
       ExtensionDownloaderDelegate::PingResult& result = ping_results_[id];
       result.did_ping = fetch_data.DidPing(id, ManifestFetchData::ROLLCALL);
       result.day_start = day_start;
     }
   }
 
   NotifyExtensionsDownloadFailed(
       not_updated,
       ExtensionDownloaderDelegate::NO_UPDATE_AVAILABLE);
 }
@@ skipping 65 matching lines @@
     }
     VLOG(2) << "will try to update " << id;
     result->push_back(i);
   }
 }
 
   // Begins (or queues up) download of an updated extension.
 void ExtensionDownloader::FetchUpdatedExtension(const std::string& id,
                                                 const GURL& url,
                                                 const std::string& hash,
-                                                const std::string& version) {
+                                                const std::string& version,
+                                                const bool is_sync) {
   if (!url.is_valid()) {
     // TODO(asargent): This can sometimes be invalid. See crbug.com/130881.
     LOG(ERROR) << "Invalid URL: '" << url.possibly_invalid_spec()
                << "' for extension " << id;
     return;
   }
 
   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_->GetURL() != url) {
-      extensions_pending_.push_back(ExtensionFetch(id, url, hash, version));
+      extensions_pending_.push_back(ExtensionFetch(id, url, hash, version,
+                                    is_sync));
     }
   } else {
     extension_fetcher_.reset(net::URLFetcher::Create(
         kExtensionFetcherId, url, net::URLFetcher::GET, this));
     extension_fetcher_->SetRequestContext(request_context_);
     extension_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                                      net::LOAD_DO_NOT_SAVE_COOKIES |
                                      net::LOAD_DISABLE_CACHE);
     // Download CRX files to a temp file. The blacklist is small and will be
     // processed in memory, so it is fetched into a string.
     if (id != kBlacklistAppID) {
       extension_fetcher_->SaveResponseToTemporaryFile(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
     }
 
     VLOG(2) << "Starting fetch of " << url << " for " << id;
 
     extension_fetcher_->Start();
-    current_extension_fetch_ = ExtensionFetch(id, url, hash, version);
+    current_extension_fetch_ = ExtensionFetch(id, url, hash, version, is_sync);
   }
 }
 
 void ExtensionDownloader::OnCRXFetchComplete(
     const net::URLFetcher* source,
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code) {
   const std::string& id = current_extension_fetch_.id;
   const ExtensionDownloaderDelegate::PingResult& ping = ping_results_[id];
@@ skipping 15 matching lines @@
       delegate_->OnBlacklistDownloadFinished(
           data, current_extension_fetch_.package_hash,
           current_extension_fetch_.version, ping);
     } else {
       FilePath crx_path;
       // Take ownership of the file at |crx_path|.
       CHECK(source->GetResponseAsFilePath(true, &crx_path));
       RecordCRXWriteHistogram(true, crx_path);
       delegate_->OnExtensionDownloadFinished(id, crx_path, url,
                                              current_extension_fetch_.version,
-                                             ping);
+                                             ping,
+                                             current_extension_fetch_.is_sync);
     }
   } 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;
     delegate_->OnExtensionDownloadFailed(
         id, ExtensionDownloaderDelegate::CRX_FETCH_FAILED, ping);
   }
 
   extension_fetcher_.reset();
   current_extension_fetch_ = ExtensionFetch();
   ping_results_.erase(id);
 
   // If there are any pending downloads left, start the next one.
   if (!extensions_pending_.empty()) {
     ExtensionFetch next = extensions_pending_.front();
     extensions_pending_.pop_front();
-    FetchUpdatedExtension(next.id, next.url, next.package_hash, next.version);
+    FetchUpdatedExtension(next.id, next.url, next.package_hash, next.version,
+                          next.is_sync);
   }
 }
 
 void ExtensionDownloader::NotifyExtensionsDownloadFailed(
-    const std::set<std::string>& extension_ids,
+    const ManifestFetchData::ExtensionInfoMap& extension_ids,
     ExtensionDownloaderDelegate::Error error) {
-  for (std::set<std::string>::const_iterator it = extension_ids.begin();
-       it != extension_ids.end(); ++it) {
-    delegate_->OnExtensionDownloadFailed(*it, error, ping_results_[*it]);
-    ping_results_.erase(*it);
+  ManifestFetchData::ExtensionInfoMap::const_iterator it;
+  for (it = extension_ids.begin(); it != extension_ids.end(); ++it) {
+    delegate_->OnExtensionDownloadFailed(it->first, error,
+                                         ping_results_[it->first]);
+    ping_results_.erase(it->first);
   }
 }
 
 void ExtensionDownloader::NotifyUpdateFound(const std::string& id) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_UPDATE_FOUND,
       content::NotificationService::AllBrowserContextsAndSources(),
       content::Details<const std::string>(&id));
 }
 
 }  // namespace extensions