WIP CallbackList in action

chrome/browser/user_style_sheet_watcher.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/user_style_sheet_watcher.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
+#include "base/callback_list.h"
 #include "base/file_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
 
 using ::base::FilePathWatcher;
 using content::BrowserThread;
 using content::WebContents;
 
@@ skipping 31 matching lines @@
 
   GURL user_style_sheet() const {
     return user_style_sheet_;
   }
 
   // Load the user style sheet on the file thread and convert it to a
   // base64 URL.  Posts the base64 URL back to the UI thread.
   void LoadStyleSheet(const base::FilePath& style_sheet_file);
 
   // Register a callback to be called whenever the stylesheet gets updated.
-  void RegisterOnStyleSheetUpdatedCallback(const base::Closure& callback);
+  base::Closure RegisterOnStyleSheetUpdatedCallback(
+      const base::Closure& callback);
 
   // Send out a notification if the stylesheet has already been loaded.
   void NotifyLoaded();
 
   // FilePathWatcher::Callback method:
   void NotifyPathChanged(const base::FilePath& path, bool error);
 
  private:
   friend class base::RefCountedThreadSafe<UserStyleSheetLoader>;
   ~UserStyleSheetLoader();
 
   // Called on the UI thread after the stylesheet has loaded.
   void SetStyleSheet(const GURL& url);
 
   // The user style sheet as a base64 data:// URL.
   GURL user_style_sheet_;
 
   // Whether the stylesheet has been loaded.
   bool has_loaded_;
 
-  std::vector<base::Closure> on_loaded_callbacks_;
+  CallbackList<base::Closure> on_loaded_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(UserStyleSheetLoader);
 };
 
 UserStyleSheetLoader::UserStyleSheetLoader()
     : has_loaded_(false) {
 }
 
-void UserStyleSheetLoader::RegisterOnStyleSheetUpdatedCallback(
+base::Closure UserStyleSheetLoader::RegisterOnStyleSheetUpdatedCallback(
     const base::Closure& callback) {
-  on_loaded_callbacks_.push_back(callback);
+  return on_loaded_callbacks_.RegisterCallback(callback);
 }
 
 void UserStyleSheetLoader::NotifyLoaded() {
-  if (has_loaded_) {
-    for (size_t i = 0; i < on_loaded_callbacks_.size(); ++i) {
-      if (!on_loaded_callbacks_[i].is_null())
-        on_loaded_callbacks_[i].Run();
-    }
-  }
+  if (has_loaded_)
+    FOR_EACH_CALLBACK(base::Closure, on_loaded_callbacks_);
 }
 
 void UserStyleSheetLoader::NotifyPathChanged(const base::FilePath& path,
                                              bool error) {
   if (!error)
     LoadStyleSheet(path);
 }
 
 void UserStyleSheetLoader::LoadStyleSheet(
     const base::FilePath& style_sheet_file) {
@@ skipping 20 matching lines @@
       const char kDataUrlPrefix[] = "data:text/css;charset=utf-8;base64,";
       style_sheet_url = GURL(kDataUrlPrefix + css_base64);
     }
   }
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&UserStyleSheetLoader::SetStyleSheet, this,
                                      style_sheet_url));
 }
 
 UserStyleSheetLoader::~UserStyleSheetLoader() {
-  on_loaded_callbacks_.clear();
+  on_loaded_callbacks_.Clear();
 }
 
 void UserStyleSheetLoader::SetStyleSheet(const GURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   has_loaded_ = true;
   user_style_sheet_ = url;
   NotifyLoaded();
 }
 
@@ skipping 34 matching lines @@
       LOG(ERROR) << "Failed to setup watch for " << style_sheet_file.value();
     }
     loader_->LoadStyleSheet(style_sheet_file);
   }
 }
 
 GURL UserStyleSheetWatcher::user_style_sheet() const {
   return loader_->user_style_sheet();
 }
 
-void UserStyleSheetWatcher::RegisterOnStyleSheetUpdatedCallback(
+base::Closure UserStyleSheetWatcher::RegisterOnStyleSheetUpdatedCallback(
     const base::Closure& callback) {
-  loader_->RegisterOnStyleSheetUpdatedCallback(callback);
+  return loader_->RegisterOnStyleSheetUpdatedCallback(callback);
 }
 
 void UserStyleSheetWatcher::Observe(int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(type == content::NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED);
   if (profile_->IsSameProfile(Profile::FromBrowserContext(
           content::Source<WebContents>(source)->GetBrowserContext()))) {
     loader_->NotifyLoaded();
     registrar_.RemoveAll();
   }
 }
 
 void UserStyleSheetWatcher::ShutdownOnUIThread() {
   registrar_.RemoveAll();
 }