Install CRX updates one at a time.

chrome/browser/extensions/extension_updater.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_UPDATER_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_UPDATER_H_
 #pragma once
 
 #include <deque>
 #include <map>
 #include <set>
+#include <stack>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_temp_dir.h"
 #include "base/task.h"
 #include "base/time.h"
@@ skipping 135 matching lines @@
 };
 
 // A class for doing auto-updates of installed Extensions. Used like this:
 //
 // ExtensionUpdater* updater = new ExtensionUpdater(my_extensions_service,
 //                                                  pref_service,
 //                                                  update_frequency_secs);
 // updater->Start();
 // ....
 // updater->Stop();
-class ExtensionUpdater : public URLFetcher::Delegate {
+class ExtensionUpdater : public URLFetcher::Delegate,
+                         public NotificationObserver {
  public:
   // Holds a pointer to the passed |service|, using it for querying installed
   // extensions and installing updated ones. The |frequency_seconds| parameter
   // controls how often update checks are scheduled.
   ExtensionUpdater(ExtensionServiceInterface* service,
                    ExtensionPrefs* extension_prefs,
                    PrefService* prefs,
                    Profile* profile,
                    int frequency_seconds);
 
@@ skipping 36 matching lines @@
     ExtensionFetch(const std::string& i, const GURL& u,
                    const std::string& h, const std::string& v);
     ~ExtensionFetch();
 
     std::string id;
     GURL url;
     std::string package_hash;
     std::string version;
   };
 
+  // FetchedCrxFile holds information about a CRX file we fetched to disk,
+  // but have not yet installed.
+  struct FetchedCrxFile {

[Matt Perry, 2011/05/31 21:34:25]

I think the implementation of this can be moved to the .cc file. You can forward
declare here:
  struct FetchedCrxFile;
then in the .cc file:
  struct ExtensionUpdater::FetchedCrxFile { impl };

I prefer to do that when possible, to avoid exposing implementation details in
the header.

[Matt Perry, 2011/05/31 21:34:25]

Put CRX in caps for consistency. Same with other methods here.

[Sam Kerner (Chrome), 2011/05/31 23:16:15]

Done.

[Sam Kerner (Chrome), 2011/05/31 23:16:15]

Done.

+    FetchedCrxFile();
+    FetchedCrxFile(const std::string& id,
+                   const FilePath& path,
+                   const GURL& download_url);
+    ~FetchedCrxFile();
+    std::string id;
+    FilePath path;
+    GURL download_url;
+  };
+
   // These are needed for unit testing, to help identify the correct mock
   // URLFetcher objects.
   static const int kManifestFetcherId = 1;
   static const int kExtensionFetcherId = 2;
 
   static const char* kBlacklistAppID;
 
   // Does common work from constructors.
   void Init();
 
@@ skipping 69 matching lines @@
 
   // Send a notification if we're finished updating.
   void NotifyIfFinished();
 
   // Adds a set of ids to in_progress_ids_.
   void AddToInProgress(const std::set<std::string>& ids);
 
   // Removes a set of ids from in_progress_ids_.
   void RemoveFromInProgress(const std::set<std::string>& ids);
 
+  // If a CRX file has been fetched but not installed, and no install is
+  // currently running, start installing.  Returns true if an install was
+  // started.
+  bool MaybeUpdateCrxFile();

[Matt Perry, 2011/05/31 21:34:25]

I think MaybeInstallCRXFile would mke more sense.

[Sam Kerner (Chrome), 2011/05/31 23:16:15]

Done.

+
+  // NotificationObserver implementation.
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
+
   // Whether Start() has been called but not Stop().
   bool alive_;
 
   base::WeakPtrFactory<ExtensionUpdater> weak_ptr_factory_;
 
   // Outstanding url fetch requests for manifests and updates.
   scoped_ptr<URLFetcher> manifest_fetcher_;
   scoped_ptr<URLFetcher> extension_fetcher_;
 
   // Pending manifests and extensions to be fetched when the appropriate fetcher
   // is available.
   std::deque<ManifestFetchData*> manifests_pending_;
   std::deque<ExtensionFetch> extensions_pending_;
 

[Matt Perry, 2011/05/31 21:34:25]

nit: remove extra newline

[Sam Kerner (Chrome), 2011/05/31 23:16:15]

Done.

+
   // The manifest currently being fetched (if any).
   scoped_ptr<ManifestFetchData> current_manifest_fetch_;
 
   // The extension currently being fetched (if any).
   ExtensionFetch current_extension_fetch_;
 
   // Pointer back to the service that owns this ExtensionUpdater.
   ExtensionServiceInterface* service_;
 
   base::OneShotTimer<ExtensionUpdater> timer_;
   int frequency_seconds_;
 
   ScopedRunnableMethodFactory<ExtensionUpdater> method_factory_;
 
   bool will_check_soon_;
 
   ExtensionPrefs* extension_prefs_;
   PrefService* prefs_;
   Profile* profile_;
   bool blacklist_checks_enabled_;
 
   // The ids of extensions that have in-progress update checks.
   std::set<std::string> in_progress_ids_;
 
+  // Observes CRX installs we initiate.
+  NotificationRegistrar registrar_;
+
+  // True when a CrxInstaller is doing an install.  Used in MaybeUpdateCrxFile()
+  // to keep more than one install from running at once.
+  bool crx_install_is_running_;
+
+  // Fetched CRX files waiting to be installed.
+  std::stack<FetchedCrxFile> fetched_crx_files_;
+
   FRIEND_TEST(ExtensionUpdaterTest, TestStartUpdateCheckMemory);
   FRIEND_TEST(ExtensionUpdaterTest, TestAfterStopBehavior);
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionUpdater);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_UPDATER_H_