Remove ref counting on sql::ErrorDelegate

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());
   }
 
   // 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 14 matching lines @@
 
   void SetForceKeepSessionState();
 
  private:
   friend class base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend>;
 
   class KillDatabaseErrorDelegate : public sql::ErrorDelegate {
    public:
     KillDatabaseErrorDelegate(Backend* backend,
                               sql::ErrorDelegate* wrapped_delegate);
+
+    virtual ~KillDatabaseErrorDelegate() {}
+
     // 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.
+    // reference (Backend -> Connection -> ErrorDelegate -> Backend).
     Backend* backend_;
-    scoped_refptr<sql::ErrorDelegate> wrapped_delegate_;
+    scoped_ptr<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;
-    }
     DCHECK(!db_.get()) << "Close should have already been called.";
     DCHECK(num_pending_ == 0 && pending_.empty());
   }
 
   // Database upgrade statements.
   bool EnsureDatabaseVersion();
 
   class PendingOperation {
    public:
     typedef enum {
@@ skipping 67 matching lines @@
   void InternalBackgroundClose();
 
   void DeleteSessionCookiesOnStartup();
 
   void DeleteSessionCookiesOnShutdown();
 
   void KillDatabase();
 
   FilePath path_;
   scoped_ptr<sql::Connection> db_;
-  scoped_refptr<KillDatabaseErrorDelegate> error_delegate_;
   sql::MetaTable meta_table_;
 
   typedef std::list<PendingOperation*> PendingOperationsList;
   PendingOperationsList pending_;
   PendingOperationsList::size_type num_pending_;
   // True if the persistent store should skip delete on exit rules.
   bool force_keep_session_state_;
   // Guard |cookies_|, |pending_|, |num_pending_|, |force_keep_session_state_|
   base::Lock lock_;
 
@@ skipping 123 matching lines @@
       // guess at how to handle them.
       break;
   }
 
   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());
+    // Avoid being called more than once. This will destroy the
+    // KillDatabaseErrorDelegate. Do not refer to any members from here forward.
+    connection->set_error_delegate(wrapped_delegate_.release());
   }
 
   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 232 matching lines @@
     return false;
   }
 
   int64 db_size = 0;
   if (file_util::GetFileSize(path_, &db_size)) {
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     UMA_HISTOGRAM_COUNTS("Cookie.DBSizeInKB", db_size / 1024 );
   }
 
   db_.reset(new sql::Connection);
-  db_->set_error_delegate(error_delegate_.get());
+  db_->set_error_delegate(
+      new KillDatabaseErrorDelegate(this, GetErrorHandlerForCookieDb()));
 
   if (!db_->Open(path_)) {
     NOTREACHED() << "Unable to open cookie DB.";
     db_.reset();
     return false;
   }
 
   if (!EnsureDatabaseVersion() || !InitTable(db_.get())) {
     NOTREACHED() << "Unable to open cookie DB.";
     db_.reset();
@@ skipping 531 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;
   }
 }