Split Autofill webdata

chrome/browser/api/webdata/web_data_service_base.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_API_WEBDATA_WEB_DATA_SERVICE_BASE_H_
 #define CHROME_BROWSER_API_WEBDATA_WEB_DATA_SERVICE_BASE_H_
 
+#include "base/callback_forward.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/supports_user_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_source.h"
 #include "sql/init_status.h"
 
 class WebDatabase;
 class WebDatabaseService;
 
 namespace base {
 class Thread;
 }
 
 // Base for WebDataService class hierarchy.
 class WebDataServiceBase
     : public base::RefCountedThreadSafe<WebDataServiceBase,
           content::BrowserThread::DeleteOnUIThread> {
  public:
   // All requests return an opaque handle of the following type.
   typedef int Handle;
 
-  WebDataServiceBase();
+  // Users of this class may provide a callback to handle errors
+  // (e.g. by showing a UI). The callback is called only on error, and
+  // takes a single parameter, the sql::InitStatus value from trying
+  // to open the database.
+
+  // TODO(joi): Should we combine this with WebDatabaseService::InitCallback?
+  typedef base::Callback<void(sql::InitStatus)> ProfileErrorCallback;
+
+  // |callback| will only be invoked on error, and only if
+  // ||callback.is_null()| evaluates to true.

[Jói, 2013/03/19 20:53:58]

||callback.is_null()| evaluates to true

-->

|callback.is_null()| evaluates to false


This makes me think you based off the older patchset (#0) of
https://codereview.chromium.org/12780012, then patched in
https://codereview.chromium.org/12494020/ without making a new branch, then kept
going on the same branch, which means you are incorporating my two branches into
this CL. That's fine, can commit them all together, as long as you have the
latest changes from both of those branches.

[Cait (Slow), 2013/03/20 22:21:10]

I updated this CL so its now based off of
https://codereview.chromium.org/12853004 (and picked up all the changes in the
pipeline as of Tuesday evening).

On 2013/03/19 20:53:58, Jói wrote:

+  WebDataServiceBase(scoped_refptr<WebDatabaseService> wdbs,
+      const ProfileErrorCallback& callback);
 
   // Cancel any pending request. You need to call this method if your
   // WebDataServiceConsumer is about to be deleted.
   virtual void CancelRequest(Handle h);
 
   // Returns the notification source for this service. This may use a
   // pointer other than this object's |this| pointer.
   virtual content::NotificationSource GetNotificationSource();
 
   // Shutdown the web data service. The service can no longer be used after this
@@ skipping 12 matching lines @@
 
   // Returns true if the database load has completetd successfully, and
   // ShutdownOnUIThread has not yet been called.
   virtual bool IsDatabaseLoaded();
 
   // Returns a pointer to the DB (used by SyncableServices). May return NULL if
   // the database is not loaded or otherwise unavailable. Must be called on
   // DBThread.
   virtual WebDatabase* GetDatabase();
 
+  // Returns a SupportsUserData objects that may be used to store data
+  // owned by the DB thread on this object. Should be called only from
+  // the DB thread, and will be destroyed on the DB thread soon after
+  // |ShutdownOnUIThread()| is called.
+  base::SupportsUserData* GetDBUserData();
+
  protected:
   virtual ~WebDataServiceBase();
+  virtual void ShutdownOnDBThread();
 
   // Our database service.
-  scoped_ptr<WebDatabaseService> wdbs_;
+  scoped_refptr<WebDatabaseService> wdbs_;
 
   // True if we've received a notification that the WebDatabase has loaded.
   bool db_loaded_;
 
  private:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   friend class base::DeleteHelper<WebDataServiceBase>;
 
+  ProfileErrorCallback profile_error_callback_;
+
+  // This makes the destructor public, and thus allows us to aggregate
+  // SupportsUserData. It is private by default to prevent incorrect
+  // usage in class hierarchies where it is inherited by
+  // reference-counted objects.
+  class SupportsUserDataAggregatable : public base::SupportsUserData {
+   public:
+    SupportsUserDataAggregatable() {}
+    virtual ~SupportsUserDataAggregatable() {}
+   private:
+    DISALLOW_COPY_AND_ASSIGN(SupportsUserDataAggregatable);
+  };
+
+  // Storage for user data to be accessed only on the DB thread. May
+  // be used e.g. for SyncableService subclasses that need to be owned
+  // by this object. Is created on first call to |GetDBUserData()|.
+  scoped_ptr<SupportsUserDataAggregatable> db_thread_user_data_;
+
   void DBInitFailed(sql::InitStatus sql_status);
   void NotifyDatabaseLoadedOnUIThread();
   void DatabaseInitOnDB(sql::InitStatus status);
 };
 
 #endif  // CHROME_BROWSER_API_WEBDATA_WEB_DATA_SERVICE_BASE_H_