Enforce the 'requirements' field in manifests.

chrome/browser/extensions/updater/extension_downloader.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_DOWNLOADER_H_
 #define CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_DOWNLOADER_H_
 #pragma once
 
 #include <deque>
 #include <map>
-#include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/extensions/updater/extension_downloader_delegate.h"
 #include "chrome/browser/extensions/updater/manifest_fetch_data.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 26 matching lines @@
   virtual ~ExtensionDownloader();
 
   // Adds |extension| to the list of extensions to check for updates.
   // Returns false if the |extension| can't be updated due to invalid details.
   // In that case, no callbacks will be performed on the |delegate_|.
   bool AddExtension(const Extension& extension);
 
   // Adds extension |id| to the list of extensions to check for updates.
   // Returns false if the |id| can't be updated due to invalid details.
   // In that case, no callbacks will be performed on the |delegate_|.
-  bool AddPendingExtension(const std::string& id, const GURL& update_url);
+  bool AddPendingExtension(const std::string& id, const GURL& update_url,
+                           bool is_sync);
 
   // Schedules a fetch of the manifest of all the extensions added with
   // AddExtension() and AddPendingExtension().
   void StartAllPending();
 
   // Schedules an update check of the blacklist.
   void StartBlacklistUpdate(const std::string& version,
                             const ManifestFetchData::PingData& ping_data);
 
   // These are needed for unit testing, to help identify the correct mock
@@ skipping 21 matching lines @@
 
     int no_url_count, google_url_count, other_url_count;
     int extension_count, theme_count, app_count, pending_count;
   };
 
   // We need to keep track of some information associated with a url
   // when doing a fetch.
   struct ExtensionFetch {
     ExtensionFetch();
     ExtensionFetch(const std::string& id, const GURL& url,
-                   const std::string& package_hash, const std::string& version);
+                   const std::string& package_hash, const std::string& version,
+                   const bool is_sync);
     ~ExtensionFetch();
 
     std::string id;
     GURL url;
     std::string package_hash;
     std::string version;
+    bool is_sync;
   };
 
   // Helper for AddExtension() and AddPendingExtension().
   bool 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);
 
   // Adds all recorded stats taken so far to histogram counts.
   void ReportStats() const;
 
   // Begins an update check. Takes ownership of |fetch_data|.
   void StartUpdateCheck(ManifestFetchData* fetch_data);
 
   // net::URLFetcherDelegate implementation.
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
@@ skipping 11 matching lines @@
   // Given a list of potential updates, returns the indices of the ones that are
   // applicable (are actually a new version, etc.) in |result|.
   void DetermineUpdates(const ManifestFetchData& fetch_data,
                         const UpdateManifest::Results& possible_updates,
                         std::vector<int>* result);
 
   // Begins (or queues up) download of an updated extension.
   void FetchUpdatedExtension(const std::string& id,
                              const GURL& url,
                              const std::string& hash,
-                             const std::string& version);
+                             const std::string& version,
+                             const bool is_sync);
 
   // Handles the result of a crx fetch.
   void OnCRXFetchComplete(const net::URLFetcher* source,
                           const GURL& url,
                           const net::URLRequestStatus& status,
                           int response_code);
 
   // Invokes OnExtensionDownloadFailed() on the |delegate_| for each extension
-  // in the set, with |error| as the reason for failure.
-  void NotifyExtensionsDownloadFailed(const std::set<std::string>& id_set,
-                                      ExtensionDownloaderDelegate::Error error);
+  // in the mamapwith |error| as the reason for failure.
+  void NotifyExtensionsDownloadFailed(
+      const ManifestFetchData::ExtensionInfoMap& id_map,
+      ExtensionDownloaderDelegate::Error error);
 
   // Send a notification that an update was found for |id| that we'll
   // attempt to download.
   void NotifyUpdateFound(const std::string& id);
 
   // The delegate that receives the crx files downloaded by the
   // ExtensionDownloader, and that fills in optional ping and update url data.
   ExtensionDownloaderDelegate* delegate_;
 
   // The request context to use for the URLFetchers.
@@ skipping 29 matching lines @@
 
   // Maps an extension-id to its PingResult data.
   std::map<std::string, ExtensionDownloaderDelegate::PingResult> ping_results_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDownloader);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_DOWNLOADER_H_