Flush Channel IDs when Cookies get saved to a persistent backend

net/cookies/cookie_monster.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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 48 matching lines @@
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
+#include "net/ssl/channel_id_service.h"
 #include "url/origin.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 // In steady state, most cookie requests can be satisfied by the in memory
 // cookie monster store. If the cookie request cannot be satisfied by the in
 // memory store, the relevant cookies must be fetched from the persistent
 // store. The task is queued in CookieMonster::tasks_pending_ if it requires
@@ skipping 261 matching lines @@
   return cookies_count;
 }
 
 }  // namespace
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
                              CookieMonsterDelegate* delegate)
     : CookieMonster(
           store,
           delegate,
+          nullptr,
+          base::TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)) {}
+
+CookieMonster::CookieMonster(PersistentCookieStore* store,
+                             CookieMonsterDelegate* delegate,
+                             ChannelIDService* channel_id_service)
+    : CookieMonster(
+          store,
+          delegate,
+          nullptr,
           base::TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)) {}
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
                              CookieMonsterDelegate* delegate,
                              base::TimeDelta last_access_threshold)
+    : CookieMonster(store, delegate, nullptr, last_access_threshold) {}
+
+CookieMonster::CookieMonster(PersistentCookieStore* store,
+                             CookieMonsterDelegate* delegate,
+                             ChannelIDService* channel_id_service,
+                             base::TimeDelta last_access_threshold)
     : initialized_(false),
       started_fetching_all_cookies_(false),
       finished_fetching_all_cookies_(false),
       fetch_strategy_(kUnknownFetch),
       seen_global_task_(false),
       store_(store),
       last_access_threshold_(last_access_threshold),
       delegate_(delegate),
+      channel_id_service_(channel_id_service),
       last_statistic_record_time_(base::Time::Now()),
       persist_session_cookies_(false),
       weak_ptr_factory_(this) {
   InitializeHistograms();
   cookieable_schemes_.insert(
       cookieable_schemes_.begin(), kDefaultCookieableSchemes,
       kDefaultCookieableSchemes + kDefaultCookieableSchemesCount);
 }
 
 // Task classes for queueing the coming request.
@@ skipping 482 matching lines @@
     const SetCookiesCallback& callback) {
   scoped_refptr<SetCookieWithDetailsTask> task = new SetCookieWithDetailsTask(
       this, url, name, value, domain, path, creation_time, expiration_time,
       last_access_time, secure, http_only, same_site, priority, callback);
   DoCookieTaskForURL(task, url);
 }
 
 void CookieMonster::FlushStore(const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (initialized_ && store_.get())
+  if (initialized_ && store_.get()) {
+    if (channel_id_service_) {
+      channel_id_service_->GetChannelIDStore()->Flush();

[mattm, 2017/05/12 00:02:47]

What thread is this getting run on? It's unclear but it seem to implicitly
require that  CookieMonster::FlushStore gets called on whatever
SQLiteChannelIDStore::Backend::background_task_runner_ is.

Additionally channel_id_service_->GetChannelIDStore()->Flush() here appears to
do a synchronous flush, while the cookiemonster store_->Flush below ends up
doing an asynchronous flush by posting to a (different?) background task.

(Have you tested this on a debug build to see if all of the thread checks pass?)

[nharper, 2017/05/12 02:47:23]

I changed this to do a PostTask on the background_task_runner_, so the channel
ID store Flush should behave the same as the cookie store flush, both in terms
of which thread its run on and being async.

+    }
     store_->Flush(callback);
-  else if (!callback.is_null())
+  } else if (!callback.is_null()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
+  }
 }
 
 void CookieMonster::SetForceKeepSessionState() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (store_)
     store_->SetForceKeepSessionState();
 }
 
 void CookieMonster::SetAllCookiesAsync(const CookieList& list,
@@ skipping 1489 matching lines @@
        it != hook_map_.end(); ++it) {
     std::pair<GURL, std::string> key = it->first;
     if (cookie.IncludeForRequestURL(key.first, opts) &&
         cookie.Name() == key.second) {
       it->second->Notify(cookie, cause);
     }
   }
 }
 
 }  // namespace net