Flush Channel IDs when Cookies get saved to a persistent backend

net/extras/sqlite/sqlite_channel_id_store.cc

 // Copyright 2014 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 "net/extras/sqlite/sqlite_channel_id_store.h"
 
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 82 matching lines @@
 
   // Post background delete of all channel ids for |server_identifiers|.
   void DeleteAllInList(const std::list<std::string>& server_identifiers);
 
   // Commit any pending operations and close the database.  This must be called
   // before the object is destructed.
   void Close();
 
   void SetForceKeepSessionState();
 
+  // Posts a task to flush pending operations to the database.
+  void Flush();
+
  private:
   friend class base::RefCountedThreadSafe<SQLiteChannelIDStore::Backend>;
 
   // You should call Close() before destructing this object.
   virtual ~Backend() {
     DCHECK(!db_.get()) << "Close should have already been called.";
     DCHECK_EQ(0u, num_pending_);
     DCHECK(pending_.empty());
   }
 
@@ skipping 361 matching lines @@
   // Perform deletion on background task runner.
   background_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &Backend::BackgroundDeleteAllInList, this, server_identifiers));
 }
 
 void SQLiteChannelIDStore::Backend::BatchOperation(
     PendingOperation::OperationType op,
     const DefaultChannelIDStore::ChannelID& channel_id) {
-  // These thresholds used to be 30 seconds or 512 outstanding operations (the
-  // same values used in CookieMonster). Since cookies can be bound to Channel
-  // IDs, it's possible for a cookie to get committed to the cookie database
-  // before the Channel ID it is bound to gets committed. Decreasing these
-  // thresholds increases the chance that the Channel ID will be committed
-  // before or at the same time as the cookie.
-
-  // Commit every 2 seconds.
-  static const int kCommitIntervalMs = 2 * 1000;
-  // Commit right away if we have more than 3 outstanding operations.
-  static const size_t kCommitAfterBatchSize = 3;
+  // Commit every 30 seconds.
+  static const int kCommitIntervalMs = 30 * 1000;
+  // Commit right away if we have more than 512 outstanding operations.
+  static const size_t kCommitAfterBatchSize = 512;
 
   // We do a full copy of the cert here, and hopefully just here.
   std::unique_ptr<PendingOperation> po(new PendingOperation(op, channel_id));
 
   PendingOperationsList::size_type num_pending;
   {
     base::AutoLock locked(lock_);
     pending_.push_back(po.release());
     num_pending = ++num_pending_;
   }
@@ skipping 26 matching lines @@
     if (remove) {
       std::unique_ptr<PendingOperation> po(*it);
       it = pending_.erase(it);
       --num_pending_;
     } else {
       ++it;
     }
   }
 }
 
+void SQLiteChannelIDStore::Backend::Flush() {
+  background_task_runner_->PostTask(FROM_HERE,
+                                    base::Bind(&Backend::Commit, this));
+}
+
 void SQLiteChannelIDStore::Backend::Commit() {
   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 
   PendingOperationsList ops;
   {
     base::AutoLock locked(lock_);
     pending_.swap(ops);
     num_pending_ = 0;
   }
 
@@ skipping 129 matching lines @@
 
 void SQLiteChannelIDStore::DeleteAllInList(
     const std::list<std::string>& server_identifiers) {
   backend_->DeleteAllInList(server_identifiers);
 }
 
 void SQLiteChannelIDStore::SetForceKeepSessionState() {
   backend_->SetForceKeepSessionState();
 }
 
+void SQLiteChannelIDStore::Flush() {
+  backend_->Flush();
+}
+
 SQLiteChannelIDStore::~SQLiteChannelIDStore() {
   backend_->Close();
   // We release our reference to the Backend, though it will probably still have
   // a reference if the background task runner has not run Close() yet.
 }
 
 }  // namespace net