Enforce the 'requirements' field in manifests.

chrome/browser/extensions/updater/extension_updater.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_updater.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 69 matching lines @@
     return extensions::ManifestFetchData::kNeverPinged;
   return SanitizeDays((Time::Now() - last_active_ping_day).InDays());
 }
 
 }  // namespace
 
 namespace extensions {
 
 ExtensionUpdater::FetchedCRXFile::FetchedCRXFile(const std::string& i,
                                                  const FilePath& p,
-                                                 const GURL& u)
+                                                 const GURL& u,
+                                                 bool is_sync)
     : id(i),
       path(p),
-      download_url(u) {}
+      download_url(u),
+      is_sync(is_sync) {}
 
 ExtensionUpdater::FetchedCRXFile::FetchedCRXFile()
     : id(""),
       path(),
-      download_url() {}
+      download_url(),
+      is_sync(false) {}
 
 ExtensionUpdater::FetchedCRXFile::~FetchedCRXFile() {}
 
 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)),
@@ skipping 194 matching lines @@
   pending_extension_manager->GetPendingIdsForUpdateCheck(&pending_ids);
 
   std::list<std::string>::const_iterator iter;
   for (iter = pending_ids.begin(); iter != pending_ids.end(); ++iter) {
     const PendingExtensionInfo* info = pending_extension_manager->GetById(
         *iter);
     if (!Extension::IsAutoUpdateableLocation(info->install_source())) {
       VLOG(2) << "Extension " << *iter << " is not auto updateable";
       continue;
     }
-    if (downloader_->AddPendingExtension(*iter, info->update_url()))
+    if (downloader_->AddPendingExtension(*iter, info->update_url(),
+                                         info->is_from_sync()))
       in_progress_ids_.push_back(*iter);
   }
 
   AddToDownloader(service_->extensions(), pending_ids);
   AddToDownloader(service_->disabled_extensions(), pending_ids);
 
   // Start a fetch of the blacklist if needed.
   if (blacklist_checks_enabled_) {
     ManifestFetchData::PingData ping_data;
     ping_data.rollcall_days =
@@ skipping 15 matching lines @@
   DCHECK(alive_);
   UpdatePingData(id, ping);
   in_progress_ids_.remove(id);
   NotifyIfFinished();
 }
 
 void ExtensionUpdater::OnExtensionDownloadFinished(const std::string& id,
                                                    const FilePath& path,
                                                    const GURL& download_url,
                                                    const std::string& version,
-                                                   const PingResult& ping) {
+                                                   const PingResult& ping,
+                                                   const bool is_sync) {
   DCHECK(alive_);
   UpdatePingData(id, ping);
 
   VLOG(2) << download_url << " written to " << path.value();
 
-  FetchedCRXFile fetched(id, path, download_url);
+  FetchedCRXFile fetched(id, path, download_url, is_sync);
   fetched_crx_files_.push(fetched);
 
   // MaybeInstallCRXFile() removes extensions from |in_progress_ids_| after
   // starting the crx installer.
   MaybeInstallCRXFile();
 }
 
 void ExtensionUpdater::OnBlacklistDownloadFinished(
     const std::string& data,
     const std::string& package_hash,
@@ skipping 133 matching lines @@
   if (in_progress_ids_.empty()) {
     VLOG(1) << "Sending EXTENSION_UPDATING_FINISHED";
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UPDATING_FINISHED,
         content::Source<Profile>(profile_),
         content::NotificationService::NoDetails());
   }
 }
 
 }  // namespace extensions