Convert NOTIFICATION_TEMPLATE_URL_SERVICE_LOADED to CallbackList

chrome/browser/search_engines/template_url_service.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_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_
 #define CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_
 
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/callback_list.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "chrome/browser/search_engines/template_url_id.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "components/browser_context_keyed_service/browser_context_keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "sync/api/sync_change.h"
@@ skipping 22 matching lines @@
 // persisted to the database maintained by WebDataService. *ALL* mutations
 // to the TemplateURLs must funnel through TemplateURLService. This allows
 // TemplateURLService to notify listeners of changes as well as keep the
 // database in sync.
 //
 // There is a TemplateURLService per Profile.
 //
 // TemplateURLService does not load the vector of TemplateURLs in its
 // constructor (except for testing). Use the Load method to trigger a load.
 // When TemplateURLService has completed loading, observers are notified via
-// OnTemplateURLServiceChanged as well as the TEMPLATE_URL_SERVICE_LOADED
-// notification message.
+// OnTemplateURLServiceChanged, or by a callback registered prior to calling
+// the Load method.
 //
 // TemplateURLService takes ownership of any TemplateURL passed to it. If there
 // is a WebDataService, deletion is handled by WebDataService, otherwise
 // TemplateURLService handles deletion.
 
 class TemplateURLService : public WebDataServiceConsumer,
                            public BrowserContextKeyedService,
                            public content::NotificationObserver,
                            public syncer::SyncableService {
  public:
   typedef std::map<std::string, std::string> QueryTerms;
   typedef std::vector<TemplateURL*> TemplateURLVector;
   // Type for a static function pointer that acts as a time source.
   typedef base::Time(TimeProvider)();
   typedef std::map<std::string, syncer::SyncData> SyncDataMap;
+  typedef base::CallbackList<void(void)>::Subscription Subscription;
 
   // Struct used for initializing the data store with fake data.
   // Each initializer is mapped to a TemplateURL.
   struct Initializer {
     const char* const keyword;
     const char* const url;
     const char* const content;
   };
 
   // Struct describes a search engine added by an extension.
@@ skipping 169 matching lines @@
   // TemplateURLService does NOT delete the observers when deleted.
   void AddObserver(TemplateURLServiceObserver* observer);
   void RemoveObserver(TemplateURLServiceObserver* observer);
 
   // Loads the keywords. This has no effect if the keywords have already been
   // loaded.
   // Observers are notified when loading completes via the method
   // OnTemplateURLServiceChanged.
   void Load();
 
+  // Registers a callback to be called when the service has loaded.
+  //
+  // If the service has already loaded, this function does nothing.
+  scoped_ptr<Subscription> RegisterOnLoadedCallback(
+      const base::Closure& callback);
+
 #if defined(UNIT_TEST)
   void set_loaded(bool value) { loaded_ = value; }
 #endif
 
   // Whether or not the keywords have been loaded.
   bool loaded() { return loaded_; }
 
   // Notification that the keywords have been loaded.
   // This is invoked from WebDataService, and should not be directly
   // invoked.
@@ skipping 155 matching lines @@
   // This does NOT notify the delegate or the database.
   //
   // This transfers ownership of the elements in |urls| to |this|, and may
   // delete some elements, so it's not safe for callers to access any elements
   // after calling; to reinforce this, this function clears |urls| on exit.
   void SetTemplateURLs(TemplateURLVector* urls);
 
   // Transitions to the loaded state.
   void ChangeToLoadedState();
 
-  // If there is a notification service, sends TEMPLATE_URL_SERVICE_LOADED
-  // notification.
+  // Runs all callbacks in |on_loaded_callbacks_|.
   void NotifyLoaded();
 
   // Saves enough of url to preferences so that it can be loaded from
   // preferences on start up.
   void SaveDefaultSearchProviderToPrefs(const TemplateURL* url);
 
   // Creates a TemplateURL that was previously saved to prefs via
   // SaveDefaultSearchProviderToPrefs or set via policy.
   // Returns true if successful, false otherwise.
   // If the user or the policy has opted for no default search, this
@@ skipping 271 matching lines @@
   // model or the underlying WebDataService prior to MergeDataAndStartSyncing.
   // This set is used to determine what entries from the server we want to
   // ignore locally and return a delete command for.
   std::set<std::string> pre_sync_deletes_;
 
   // This is used to log the origin of changes to the default search provider.
   // We set this value to increasingly specific values when we know what is the
   // cause/origin of a default search change.
   DefaultSearchChangeOrigin dsp_change_origin_;
 
+  // Stores a list of callbacks to be run after TemplateURLService has loaded.
+  base::CallbackList<void(void)> on_loaded_callbacks_;
+
   DISALLOW_COPY_AND_ASSIGN(TemplateURLService);
 };
 
 #endif  // CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_