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 the database.
     63   void ShutdownDatabase();
     64 
     65   // Task wrappers to update requests and and notify |request_manager_|. These
     66   // are used in cases where the request is being made from the UI thread and an
     67   // asyncronous callback is required to notify the client of |request|'s
     68   // completion.
     69   void DBWriteTaskWrapper(
     70       const WebDatabaseService::WriteTask& task,
     71       scoped_ptr<WebDataRequest> request);
     72   void DBReadTaskWrapper(
     73       const WebDatabaseService::ReadTask& task,
     74       scoped_ptr<WebDataRequest> request);
     75 
     76   // Task runners to run database tasks.
     77   void ExecuteWriteTask(const WebDatabaseService::WriteTask& task);
     78   scoped_ptr<WDTypedResult> ExecuteReadTask(
     79       const WebDatabaseService::ReadTask& task);
     80 
     81   const scoped_refptr<WebDataRequestManager>& request_manager() {
     82     return request_manager_;
     83   }
     84 
     85   WebDatabase* database() { return db_.get(); }
     86 
     87  protected:
     88   friend class base::RefCountedDeleteOnMessageLoop<WebDataServiceBackend>;
     89   friend class base::DeleteHelper<WebDataServiceBackend>;
     90 
     91   virtual ~WebDataServiceBackend();
     92 
     93  private:
     94   // Commit the current transaction.
     95   void Commit();
     96 
     97   // Path to database file.
     98   base::FilePath db_path_;
     99 
    100   // The tables that participate in managing the database. These are
    101   // owned here but other than that this class does nothing with
    102   // them. Their initialization is in whatever factory creates
    103   // WebDatabaseService, and lookup by type is provided by the
    104   // WebDatabase class. The tables need to be owned by this refcounted
    105   // object, or they themselves would need to be refcounted. Owning
    106   // them here rather than having WebDatabase own them makes for
    107   // easier unit testing of WebDatabase.
    108   ScopedVector<WebDatabaseTable> tables_;
    109 
    110   scoped_ptr<WebDatabase> db_;
    111 
    112   // Keeps track of all pending requests made to the db.
    113   scoped_refptr<WebDataRequestManager> request_manager_;
    114 
    115   // State of database initialization. Used to prevent the executing of tasks
    116   // before the db is ready.
    117   sql::InitStatus init_status_;
    118 
    119   // True if an attempt has been made to load the database (even if the attempt
    120   // fails), used to avoid continually trying to reinit if the db init fails.
    121   bool init_complete_;
    122 
    123   // Delegate. See the class definition above for more information.
    124   scoped_ptr<Delegate> delegate_;
    125 
    126   DISALLOW_COPY_AND_ASSIGN(WebDataServiceBackend);
    127 };
    128 
    129 #endif  // COMPONENTS_WEBDATA_COMMON_WEB_DATA_SERVICE_BACKEND_H_
    130