Home | History | Annotate | Download | only in common 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef COMPONENTS_WEBDATA_COMMON_WEB_DATA_SERVICE_BACKEND_H_
      6 #define COMPONENTS_WEBDATA_COMMON_WEB_DATA_SERVICE_BACKEND_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/callback_forward.h"
     10 #include "base/compiler_specific.h"
     11 #include "base/files/file_path.h"
     12 #include "base/memory/ref_counted.h"
     13 #include "base/memory/ref_counted_delete_on_message_loop.h"
     14 #include "base/memory/scoped_ptr.h"
     15 #include "base/memory/scoped_vector.h"
     16 #include "components/webdata/common/web_database_service.h"
     17 #include "components/webdata/common/webdata_export.h"
     18 
     19 class WebDatabase;
     20 class WebDatabaseTable;
     21 class WebDataRequest;
     22 class WebDataRequestManager;
     23 
     24 namespace tracked_objects {
     25 class Location;
     26 }
     27 
     28 // WebDataServiceBackend handles all database tasks posted by
     29 // WebDatabaseService. It is refcounted to allow asynchronous destruction on the
     30 // DB thread.
     31 
     32 // TODO(caitkp): Rename this class to WebDatabaseBackend.
     33 
     34 class WEBDATA_EXPORT WebDataServiceBackend
     35     : public base::RefCountedDeleteOnMessageLoop<WebDataServiceBackend> {
     36  public:
     37   class Delegate {
     38     public:
     39     virtual ~Delegate() {}
     40 
     41     // Invoked when the backend has finished loading the db.
     42     virtual void DBLoaded(sql::InitStatus status) = 0;
     43   };
     44 
     45   WebDataServiceBackend(const base::FilePath& path,
     46                         Delegate* delegate,
     47                         const scoped_refptr<base::MessageLoopProxy>& db_thread);
     48 
     49   // Must call only before InitDatabaseWithCallback.
     50   void AddTable(scoped_ptr<WebDatabaseTable> table);
     51 
     52   // Initializes the database and notifies caller via callback when complete.
     53   // Callback is called synchronously.
     54   void InitDatabase();
     55 
     56   // Opens the database file from the profile path if an init has not yet been
     57   // attempted. Separated from the constructor to ease construction/destruction
     58   // of this object on one thread but database access on the DB thread. Returns
     59   // the status of the database.
     60   sql::InitStatus LoadDatabaseIfNecessary();
     61 
     62   // Shuts down database. |should_reinit| tells us whether or not it should be
     63   // possible to re-initialize the DB after the shutdown.
     64   void ShutdownDatabase(bool should_reinit);
     65 
     66   // Task wrappers to update requests and and notify |request_manager_|. These
     67   // are used in cases where the request is being made from the UI thread and an
     68   // asyncronous callback is required to notify the client of |request|'s
     69   // completion.
     70   void DBWriteTaskWrapper(
     71       const WebDatabaseService::WriteTask& task,
     72       scoped_ptr<WebDataRequest> request);
     73   void DBReadTaskWrapper(
     74       const WebDatabaseService::ReadTask& task,
     75       scoped_ptr<WebDataRequest> request);
     76 
     77   // Task runners to run database tasks.
     78   void ExecuteWriteTask(const WebDatabaseService::WriteTask& task);
     79   scoped_ptr<WDTypedResult> ExecuteReadTask(
     80       const WebDatabaseService::ReadTask& task);
     81 
     82   const scoped_refptr<WebDataRequestManager>& request_manager() {
     83     return request_manager_;
     84   }
     85 
     86   WebDatabase* database() { return db_.get(); }
     87 
     88  protected:
     89   friend class base::RefCountedDeleteOnMessageLoop<WebDataServiceBackend>;
     90   friend class base::DeleteHelper<WebDataServiceBackend>;
     91 
     92   virtual ~WebDataServiceBackend();
     93 
     94  private:
     95   // Commit the current transaction.
     96   void Commit();
     97 
     98   // Path to database file.
     99   base::FilePath db_path_;
    100 
    101   // The tables that participate in managing the database. These are
    102   // owned here but other than that this class does nothing with
    103   // them. Their initialization is in whatever factory creates
    104   // WebDatabaseService, and lookup by type is provided by the
    105   // WebDatabase class. The tables need to be owned by this refcounted
    106   // object, or they themselves would need to be refcounted. Owning
    107   // them here rather than having WebDatabase own them makes for
    108   // easier unit testing of WebDatabase.
    109   ScopedVector<WebDatabaseTable> tables_;
    110 
    111   scoped_ptr<WebDatabase> db_;
    112 
    113   // Keeps track of all pending requests made to the db.
    114   scoped_refptr<WebDataRequestManager> request_manager_;
    115 
    116   // State of database initialization. Used to prevent the executing of tasks
    117   // before the db is ready.
    118   sql::InitStatus init_status_;
    119 
    120   // True if an attempt has been made to load the database (even if the attempt
    121   // fails), used to avoid continually trying to reinit if the db init fails.
    122   bool init_complete_;
    123 
    124   // Delegate. See the class definition above for more information.
    125   scoped_ptr<Delegate> delegate_;
    126 
    127   DISALLOW_COPY_AND_ASSIGN(WebDataServiceBackend);
    128 };
    129 
    130 #endif  // COMPONENTS_WEBDATA_COMMON_WEB_DATA_SERVICE_BACKEND_H_
    131