Allow multiple sql::Connection error delegates.

chrome/browser/net/sqlite_persistent_cookie_store.cc

 // 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.
 
 #include "chrome/browser/net/sqlite_persistent_cookie_store.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 57 matching lines @@
       : path_(path),
         db_(NULL),
         num_pending_(0),
         force_keep_session_state_(false),
         initialized_(false),
         restore_old_session_cookies_(restore_old_session_cookies),
         clear_on_exit_policy_(clear_on_exit_policy),
         num_cookies_read_(0),
         num_priority_waiting_(0),
         total_priority_requests_(0) {
-    error_delegate_ =
-      new KillDatabaseErrorDelegate(this, GetErrorHandlerForCookieDb());
+    error_delegate_ = new KillDatabaseErrorDelegate(this);
   }
 
   // Creates or loads the SQLite database.
   void Load(const LoadedCallback& loaded_callback);
 
   // Loads cookies for the domain key (eTLD+1).
   void LoadCookiesForKey(const std::string& domain,
       const LoadedCallback& loaded_callback);
 
   // Batch a cookie addition.
@@ skipping 12 matching lines @@
   // before the object is destructed.
   void Close();
 
   void SetForceKeepSessionState();
 
  private:
   friend class base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend>;
 
   class KillDatabaseErrorDelegate : public sql::ErrorDelegate {
    public:
-    KillDatabaseErrorDelegate(Backend* backend,
-                              sql::ErrorDelegate* wrapped_delegate);
+    explicit KillDatabaseErrorDelegate(Backend* backend);
     // ErrorDelegate implementation.
     virtual int OnError(int error,
                         sql::Connection* connection,
                         sql::Statement* stmt) OVERRIDE;
 
     void reset_backend() {
       backend_ = NULL;
     }
 
    protected:
     virtual ~KillDatabaseErrorDelegate() {}
 
    private:
 
     // Do not increment the count on Backend, as that would create a circular
     // reference (Backend -> Connection -> ErrorDelegate -> Backend). Instead,
     // Backend will call reset_backend() when it is going away.
     Backend* backend_;
-    scoped_refptr<sql::ErrorDelegate> wrapped_delegate_;
 
     DISALLOW_COPY_AND_ASSIGN(KillDatabaseErrorDelegate);
   };
 
   // You should call Close() before destructing this object.
   ~Backend() {
     if (error_delegate_.get()) {
       error_delegate_->reset_backend();
       error_delegate_ = NULL;
     }
@@ skipping 135 matching lines @@
   // The time when |num_priority_waiting_| incremented to 1.
   base::Time current_priority_wait_start_;
   // The cumulative duration of time when |num_priority_waiting_| was greater
   // than 1.
   base::TimeDelta priority_wait_duration_;
 
   DISALLOW_COPY_AND_ASSIGN(Backend);
 };
 
 SQLitePersistentCookieStore::Backend::KillDatabaseErrorDelegate::
-KillDatabaseErrorDelegate(Backend* backend,
-                          sql::ErrorDelegate* wrapped_delegate)
-    : backend_(backend),
-      wrapped_delegate_(wrapped_delegate) {
+KillDatabaseErrorDelegate(Backend* backend)
+    : backend_(backend) {
 }
 
 int SQLitePersistentCookieStore::Backend::KillDatabaseErrorDelegate::OnError(
     int error, sql::Connection* connection, sql::Statement* stmt) {
-  if (wrapped_delegate_.get())
-    error = wrapped_delegate_->OnError(error, connection, stmt);
-
   bool delete_db = false;
 
   switch (error) {
     case SQLITE_DONE:
     case SQLITE_OK:
       // Theoretically, the wrapped delegate might have resolved the error, and
       // we would end up here.
       break;
 
     case SQLITE_CORRUPT:
@@ skipping 58 matching lines @@
 
   if (delete_db && backend_) {
     // Don't just do the close/delete here, as we are being called by |db| and
     // that seems dangerous.
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&Backend::KillDatabase, backend_));
 
     // Avoid being called more than once. There should still be a reference to
     // this ErrorDelegate in the backend, but just in case don't refer to any
     // members from here forward.
-    connection->set_error_delegate(wrapped_delegate_.get());
+    connection->remove_error_delegate(this);
   }
 
   return error;
 }
 
 // Version number of the database.
 //
 // Version 5 adds the columns has_expires and is_persistent, so that the
 // database can store session cookies as well as persistent cookies. Databases
 // of version 5 are incompatible with older versions of code. If a database of
@@ skipping 784 matching lines @@
 }
 
 SQLitePersistentCookieStore::~SQLitePersistentCookieStore() {
   if (backend_.get()) {
     backend_->Close();
     // Release our reference, it will probably still have a reference if the
     // background thread has not run Close() yet.
     backend_ = NULL;
   }
 }