Offer user to send feedback from profile error dialog

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 <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/webdata/common/web_data_request_manager.h"
 #include "components/webdata/common/web_data_results.h"
 #include "components/webdata/common/web_data_service_consumer.h"
 #include "components/webdata/common/web_database_backend.h"
 
 using base::Bind;
 using base::FilePath;
 
 // Receives messages from the backend on the DB thread, posts them to
 // WebDatabaseService on the UI thread.
 class WebDatabaseService::BackendDelegate
     : public WebDatabaseBackend::Delegate {
  public:
   BackendDelegate(const base::WeakPtr<WebDatabaseService>& web_database_service)
       : web_database_service_(web_database_service),
         callback_thread_(base::ThreadTaskRunnerHandle::Get()) {}
 
-  void DBLoaded(sql::InitStatus status) override {
+  void DBLoaded(sql::InitStatus status,
+                const sql::DatabaseDiagnosticMap& diagnostics) override {
     callback_thread_->PostTask(
-        FROM_HERE,
-        base::Bind(&WebDatabaseService::OnDatabaseLoadDone,
-                   web_database_service_,
-                   status));
+        FROM_HERE, base::Bind(&WebDatabaseService::OnDatabaseLoadDone,
+                              web_database_service_, status, diagnostics));
   }
  private:
   const base::WeakPtr<WebDatabaseService> web_database_service_;
   scoped_refptr<base::SingleThreadTaskRunner> callback_thread_;
 };
 
 WebDatabaseService::WebDatabaseService(
     const base::FilePath& path,
     scoped_refptr<base::SingleThreadTaskRunner> ui_thread,
     scoped_refptr<base::SingleThreadTaskRunner> db_thread)
@@ skipping 80 matching lines @@
 void WebDatabaseService::RegisterDBLoadedCallback(
     const DBLoadedCallback& callback) {
   loaded_callbacks_.push_back(callback);
 }
 
 void WebDatabaseService::RegisterDBErrorCallback(
     const DBLoadErrorCallback& callback) {
   error_callbacks_.push_back(callback);
 }
 
-void WebDatabaseService::OnDatabaseLoadDone(sql::InitStatus status) {
+void WebDatabaseService::OnDatabaseLoadDone(
+    sql::InitStatus status,
+    const sql::DatabaseDiagnosticMap& diagnostics) {
   if (status == sql::INIT_OK) {
     db_loaded_ = true;
 
     for (size_t i = 0; i < loaded_callbacks_.size(); i++) {
       if (!loaded_callbacks_[i].is_null())
         loaded_callbacks_[i].Run();
     }
 
     loaded_callbacks_.clear();
   } else {
     // Notify that the database load failed.
     for (size_t i = 0; i < error_callbacks_.size(); i++) {
       if (!error_callbacks_[i].is_null())
-        error_callbacks_[i].Run(status);
+        error_callbacks_[i].Run(status, diagnostics);
     }
 
     error_callbacks_.clear();
   }

[michaeln, 2016/07/09 03:00:38]

off topic: should both set of callbacks be cleared upon load completion?

[afakhry, 2016/07/11 16:47:45]

I'm not sure of the expectations of the clients; i.e. do they expect their error
callbacks remain registered until the first error occurs, at which point they
also expect their "loaded" callbacks remain registered so that they can try
loading again?

 }