Replace WebDatabaseObserver with callbacks

components/webdata/common/web_database_service.cc

 // Copyright 2013 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 "components/webdata/common/web_database_service.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "components/webdata/common/web_data_request_manager.h"
 #include "components/webdata/common/web_data_results.h"
@@ skipping 22 matching lines @@
                    web_database_service_,
                    status));
   }
  private:
   const base::WeakPtr<WebDatabaseService> web_database_service_;
 };
 
 WebDatabaseService::WebDatabaseService(
     const base::FilePath& path)
     : path_(path),
-      weak_ptr_factory_(this) {
+      weak_ptr_factory_(this),
+      db_loaded_(false) {
   // WebDatabaseService should be instantiated on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // WebDatabaseService requires DB thread if instantiated.
   DCHECK(BrowserThread::IsWellKnownThread(BrowserThread::DB));
 }
 
 WebDatabaseService::~WebDatabaseService() {
 }
 
 void WebDatabaseService::AddTable(scoped_ptr<WebDatabaseTable> table) {
   if (!wds_backend_.get()) {
     wds_backend_ = new WebDataServiceBackend(
         path_, new BackendDelegate(weak_ptr_factory_.GetWeakPtr()));
   }
   wds_backend_->AddTable(table.Pass());
 }
 
 void WebDatabaseService::LoadDatabase() {
   DCHECK(wds_backend_.get());
 
   BrowserThread::PostTask(
       BrowserThread::DB,
       FROM_HERE,
       Bind(&WebDataServiceBackend::InitDatabase, wds_backend_));
 }
 
 void WebDatabaseService::UnloadDatabase() {
+  db_loaded_ = false;
   if (!wds_backend_.get())
     return;
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       Bind(&WebDataServiceBackend::ShutdownDatabase,
            wds_backend_, true));
 }
 
 void WebDatabaseService::ShutdownDatabase() {
+  db_loaded_ = false;
   if (!wds_backend_.get())
     return;
   weak_ptr_factory_.InvalidateWeakPtrs();
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       Bind(&WebDataServiceBackend::ShutdownDatabase,
            wds_backend_, false));
 }
 
 WebDatabase* WebDatabaseService::GetDatabaseOnDB() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
@@ skipping 44 matching lines @@
 
   return handle;
 }
 
 void WebDatabaseService::CancelRequest(WebDataServiceBase::Handle h) {
   if (!wds_backend_.get())
     return;
   wds_backend_->request_manager()->CancelRequest(h);
 }
 
-void WebDatabaseService::AddObserver(WebDatabaseObserver* observer) {
-  observer_list_.AddObserver(observer);
+void WebDatabaseService::RegisterDBLoadedCallback(
+    const base::Callback<void(void)>& callback) {
+  pending_callbacks_.push_back(callback);

[Cait (Slow), 2013/06/05 19:14:48]

I'm wondering if I should handle callbacks added post-DB-load (i.e. call them
immediately). Doing so would require storing some info about the DB state (did
we try to load it and fail? why did it fail? etc) in this class which is already
stored in the backend, and this seems a bit redundant. 

Maybe it is sufficient to document that callbacks added after the loading is
finished won't get called (esp. since there is an IsDBLoaded() method)? 

[Jói, 2013/06/06 11:37:17]

I think just documenting is sufficient.

 }
 
-void WebDatabaseService::RemoveObserver(WebDatabaseObserver* observer) {
-  observer_list_.RemoveObserver(observer);
+void WebDatabaseService::RegisterDBErrorCallback(
+    const base::Callback<void(sql::InitStatus)>& callback) {
+  error_callbacks_.push_back(callback);
 }
 
 void WebDatabaseService::OnDatabaseLoadDone(sql::InitStatus status) {
   if (status == sql::INIT_OK) {
-    // Notify that the database has been initialized.
-    FOR_EACH_OBSERVER(WebDatabaseObserver,
-                      observer_list_,
-                      WebDatabaseLoaded());
+    db_loaded_ = true;
+
+    for (size_t i = 0; i < pending_callbacks_.size(); i++)
+      pending_callbacks_[i].Run();
+
+    pending_callbacks_.clear();
   } else {
     // Notify that the database load failed.
-    FOR_EACH_OBSERVER(WebDatabaseObserver,
-                      observer_list_,
-                      WebDatabaseLoadFailed(status));
+    for (size_t i = 0; i < error_callbacks_.size(); i++)
+      error_callbacks_[i].Run(status);
+
+    error_callbacks_.clear();
   }
 }