BASELINE: Update Chromium to 70.0.3538.78

Change-Id: Ie634710bf039e26c1957f4ae45e101bd4c434ae7
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

14 files changed, 439 insertions, 107 deletions

diff --git a/chromium/net/cookies/cookie_change_dispatcher.cc b/chromium/net/cookies/cookie_change_dispatcher.cc
index 4bb4e5f9fff..c6cdf324aa8 100644
--- a/chromium/net/cookies/cookie_change_dispatcher.cc
+++ b/chromium/net/cookies/cookie_change_dispatcher.cc
@@ -6,6 +6,34 @@
 
 namespace net {
 
+const char* CookieChangeCauseToString(CookieChangeCause cause) {
+  const char* cause_string = "INVALID";
+  switch (cause) {
+    case CookieChangeCause::INSERTED:
+      cause_string = "inserted";
+      break;
+    case CookieChangeCause::EXPLICIT:
+      cause_string = "explicit";
+      break;
+    case CookieChangeCause::UNKNOWN_DELETION:
+      cause_string = "unknown";
+      break;
+    case CookieChangeCause::OVERWRITE:
+      cause_string = "overwrite";
+      break;
+    case CookieChangeCause::EXPIRED:
+      cause_string = "expired";
+      break;
+    case CookieChangeCause::EVICTED:
+      cause_string = "evicted";
+      break;
+    case CookieChangeCause::EXPIRED_OVERWRITE:
+      cause_string = "expired_overwrite";
+      break;
+  }
+  return cause_string;
+}
+
 bool CookieChangeCauseIsDeletion(CookieChangeCause cause) {
   return cause != CookieChangeCause::INSERTED;
 }
diff --git a/chromium/net/cookies/cookie_change_dispatcher.h b/chromium/net/cookies/cookie_change_dispatcher.h
index 8b48c046f6a..c05a6db5d33 100644
--- a/chromium/net/cookies/cookie_change_dispatcher.h
+++ b/chromium/net/cookies/cookie_change_dispatcher.h
@@ -38,9 +38,12 @@ enum class CookieChangeCause {
   EXPIRED_OVERWRITE
 };
 
+// Return a string corresponding to the change cause.  For debugging/logging.
+NET_EXPORT const char* CookieChangeCauseToString(CookieChangeCause cause);
+
 // Returns whether |cause| is one that could be a reason for deleting a cookie.
 // This function assumes that ChangeCause::EXPLICIT is a reason for deletion.
-bool NET_EXPORT CookieChangeCauseIsDeletion(CookieChangeCause cause);
+NET_EXPORT bool CookieChangeCauseIsDeletion(CookieChangeCause cause);
 
 // Called when a cookie is changed in a CookieStore.
 //
diff --git a/chromium/net/cookies/cookie_constants.cc b/chromium/net/cookies/cookie_constants.cc
index b618261f8b2..14140d3d5d0 100644
--- a/chromium/net/cookies/cookie_constants.cc
+++ b/chromium/net/cookies/cookie_constants.cc
@@ -17,6 +17,7 @@ const char kPriorityHigh[] = "high";
 
 const char kSameSiteLax[] = "lax";
 const char kSameSiteStrict[] = "strict";
+const char kSameSiteDefault[] = "default";
 
 }  // namespace
 
@@ -47,6 +48,18 @@ CookiePriority StringToCookiePriority(const std::string& priority) {
   return COOKIE_PRIORITY_DEFAULT;
 }
 
+std::string CookieSameSiteToString(CookieSameSite same_site) {
+  switch (same_site) {
+    case CookieSameSite::LAX_MODE:
+      return kSameSiteLax;
+    case CookieSameSite::STRICT_MODE:
+      return kSameSiteStrict;
+    case CookieSameSite::DEFAULT_MODE:
+      return kSameSiteDefault;
+  }
+  return "INVALID";
+}
+
 CookieSameSite StringToCookieSameSite(const std::string& same_site) {
   if (base::EqualsCaseInsensitiveASCII(same_site, kSameSiteLax))
     return CookieSameSite::LAX_MODE;
diff --git a/chromium/net/cookies/cookie_constants.h b/chromium/net/cookies/cookie_constants.h
index 3f5b3cf7dda..d4f82afbf50 100644
--- a/chromium/net/cookies/cookie_constants.h
+++ b/chromium/net/cookies/cookie_constants.h
@@ -37,6 +37,10 @@ NET_EXPORT std::string CookiePriorityToString(CookiePriority priority);
 // Defaults to COOKIE_PRIORITY_DEFAULT for empty or unrecognized strings.
 NET_EXPORT CookiePriority StringToCookiePriority(const std::string& priority);
 
+// Returns a string corresponding to the value of the |same_site| token.
+// Intended only for debugging/logging.
+NET_EXPORT std::string CookieSameSiteToString(CookieSameSite same_site);
+
 // Converts the Set-Cookie header SameSite token |same_site| to a
 // CookieSameSite. Defaults to CookieSameSite::DEFAULT_MODE for empty or
 // unrecognized strings.
diff --git a/chromium/net/cookies/cookie_monster.cc b/chromium/net/cookies/cookie_monster.cc
index 3f7095682c8..40f30163370 100644
--- a/chromium/net/cookies/cookie_monster.cc
+++ b/chromium/net/cookies/cookie_monster.cc
@@ -67,8 +67,10 @@
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_monster_change_dispatcher.h"
+#include "net/cookies/cookie_monster_netlog_params.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
+#include "net/log/net_log.h"
 #include "net/ssl/channel_id_service.h"
 #include "url/origin.h"
 
@@ -348,30 +350,30 @@ size_t CountCookiesForPossibleDeletion(
 
 }  // namespace
 
-CookieMonster::CookieMonster(scoped_refptr<PersistentCookieStore> store)
-    : CookieMonster(
-          std::move(store),
-          nullptr,
-          base::TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)) {}
-
 CookieMonster::CookieMonster(scoped_refptr<PersistentCookieStore> store,
-                             ChannelIDService* channel_id_service)
+                             ChannelIDService* channel_id_service,
+                             NetLog* net_log)
     : CookieMonster(
           std::move(store),
           channel_id_service,
-          base::TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)) {}
+          base::TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds),
+          net_log) {}
 
 CookieMonster::CookieMonster(scoped_refptr<PersistentCookieStore> store,
-                             base::TimeDelta last_access_threshold)
-    : CookieMonster(std::move(store), nullptr, last_access_threshold) {}
+                             base::TimeDelta last_access_threshold,
+                             NetLog* net_log)
+    : CookieMonster(std::move(store), nullptr, last_access_threshold, net_log) {
+}
 
 CookieMonster::CookieMonster(scoped_refptr<PersistentCookieStore> store,
                              ChannelIDService* channel_id_service,
-                             base::TimeDelta last_access_threshold)
+                             base::TimeDelta last_access_threshold,
+                             NetLog* net_log)
     : initialized_(false),
       started_fetching_all_cookies_(false),
       finished_fetching_all_cookies_(false),
       seen_global_task_(false),
+      net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::COOKIE_STORE)),
       store_(std::move(store)),
       last_access_threshold_(last_access_threshold),
       channel_id_service_(channel_id_service),
@@ -393,6 +395,10 @@ CookieMonster::CookieMonster(scoped_refptr<PersistentCookieStore> store,
         base::Bind(&ChannelIDStore::Flush,
                    base::Unretained(channel_id_service_->GetChannelIDStore())));
   }
+  net_log_.BeginEvent(
+      NetLogEventType::COOKIE_STORE_ALIVE,
+      base::BindRepeating(&NetLogCookieMonsterConstructorCallback,
+                          store != nullptr, channel_id_service != nullptr));
 }
 
 // Asynchronous CookieMonster API
@@ -551,6 +557,9 @@ void CookieMonster::SetCookieableSchemes(
 void CookieMonster::SetPersistSessionCookies(bool persist_session_cookies) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!initialized_);
+  net_log_.AddEvent(
+      NetLogEventType::COOKIE_STORE_SESSION_PERSISTENCE,
+      NetLog::BoolCallback("persistence", persist_session_cookies));
   persist_session_cookies_ = persist_session_cookies;
 }
 
@@ -615,6 +624,7 @@ CookieMonster::~CookieMonster() {
     InternalDeleteCookie(current_cookie_it, false /* sync_to_store */,
                          DELETE_COOKIE_DONT_RECORD);
   }
+  net_log_.EndEvent(NetLogEventType::COOKIE_STORE_ALIVE);
 }
 
 void CookieMonster::GetAllCookies(GetCookieListCallback callback) {
@@ -854,7 +864,8 @@ void CookieMonster::FetchAllCookies() {
   // We bind in the current time so that we can report the wall-clock time for
   // loading cookies.
   store_->Load(base::Bind(&CookieMonster::OnLoaded,
-                          weak_ptr_factory_.GetWeakPtr(), TimeTicks::Now()));
+                          weak_ptr_factory_.GetWeakPtr(), TimeTicks::Now()),
+               net_log_);
 }
 
 void CookieMonster::OnLoaded(
@@ -910,8 +921,9 @@ void CookieMonster::StoreLoadedCookies(
         GetKey(cookie_ptr->Domain()), std::move(cookie), false);
     const Time cookie_access_time(cookie_ptr->LastAccessDate());
     if (earliest_access_time_.is_null() ||
-        cookie_access_time < earliest_access_time_)
+        cookie_access_time < earliest_access_time_) {
       earliest_access_time_ = cookie_access_time;
+    }
 
     if (ContainsControlCharacter(cookie_ptr->Name()) ||
         ContainsControlCharacter(cookie_ptr->Value())) {
@@ -1142,6 +1154,10 @@ bool CookieMonster::DeleteAnyEquivalentCookie(
       skipped_secure_cookie = true;
       histogram_cookie_delete_equivalent_->Add(
           COOKIE_DELETE_EQUIVALENT_SKIPPING_SECURE);
+      net_log_.AddEvent(
+          NetLogEventType::COOKIE_STORE_COOKIE_REJECTED_SECURE,
+          base::BindRepeating(&NetLogCookieMonsterCookieRejectedSecure, cc,
+                              &ecc));
       // If the cookie is equivalent to the new cookie and wouldn't have been
       // skipped for being HTTP-only, record that it is a skipped secure cookie
       // that would have been deleted otherwise.
@@ -1162,6 +1178,10 @@ bool CookieMonster::DeleteAnyEquivalentCookie(
           << "Duplicate equivalent cookies found, cookie store is corrupted.";
       if (skip_httponly && cc->IsHttpOnly()) {
         skipped_httponly = true;
+        net_log_.AddEvent(
+            NetLogEventType::COOKIE_STORE_COOKIE_REJECTED_HTTPONLY,
+            base::BindRepeating(&NetLogCookieMonsterCookieRejectedHttponly, cc,
+                                &ecc));
       } else {
         histogram_cookie_delete_equivalent_->Add(
             COOKIE_DELETE_EQUIVALENT_FOUND);
@@ -1187,9 +1207,13 @@ CookieMonster::CookieMap::iterator CookieMonster::InternalInsertCookie(
   DCHECK(thread_checker_.CalledOnValidThread());
   CanonicalCookie* cc_ptr = cc.get();
 
+  net_log_.AddEvent(NetLogEventType::COOKIE_STORE_COOKIE_ADDED,
+                    base::BindRepeating(&NetLogCookieMonsterCookieAdded,
+                                        cc.get(), sync_to_store));
   if ((cc_ptr->IsPersistent() || persist_session_cookies_) && store_.get() &&
-      sync_to_store)
+      sync_to_store) {
     store_->AddCookie(*cc_ptr);
+  }
   CookieMap::iterator inserted =
       cookies_.insert(CookieMap::value_type(key, std::move(cc)));
 
@@ -1362,10 +1386,17 @@ void CookieMonster::InternalDeleteCookie(CookieMap::iterator it,
       << "InternalDeleteCookie()"
       << ", cause:" << deletion_cause << ", cc: " << cc->DebugString();
 
+  ChangeCausePair mapping = kChangeCauseMapping[deletion_cause];
+  if (deletion_cause != DELETE_COOKIE_DONT_RECORD) {
+    net_log_.AddEvent(NetLogEventType::COOKIE_STORE_COOKIE_DELETED,
+                      base::BindRepeating(&NetLogCookieMonsterCookieDeleted, cc,
+                                          mapping.cause, sync_to_store));
+  }
+
   if ((cc->IsPersistent() || persist_session_cookies_) && store_.get() &&
-      sync_to_store)
+      sync_to_store) {
     store_->DeleteCookie(*cc);
-  ChangeCausePair mapping = kChangeCauseMapping[deletion_cause];
+  }
   change_dispatcher_.DispatchChange(*cc, mapping.cause, mapping.notify);
   cookies_.erase(it);
 }
diff --git a/chromium/net/cookies/cookie_monster.h b/chromium/net/cookies/cookie_monster.h
index 11a4ff17dc1..9251db4dd49 100644
--- a/chromium/net/cookies/cookie_monster.h
+++ b/chromium/net/cookies/cookie_monster.h
@@ -31,6 +31,7 @@
 #include "net/cookies/cookie_constants.h"
 #include "net/cookies/cookie_monster_change_dispatcher.h"
 #include "net/cookies/cookie_store.h"
+#include "net/log/net_log_with_source.h"
 #include "url/gurl.h"
 
 namespace base {
@@ -130,18 +131,19 @@ class NET_EXPORT CookieMonster : public CookieStore {
   // class will take care of initializing it. The backing store is NOT owned by
   // this class, but it must remain valid for the duration of the cookie
   // monster's existence. If |store| is NULL, then no backing store will be
-  // updated.
-  explicit CookieMonster(scoped_refptr<PersistentCookieStore> store);
-
-  // Like above, but includes a non-owning pointer |channel_id_service| for the
+  // updated. |channel_id_service| is a non-owninng pointer for the
   // corresponding ChannelIDService used with this CookieStore. The
-  // |channel_id_service| must outlive the CookieMonster.
+  // |channel_id_service| must outlive the CookieMonster. |net_log| must outlive
+  // the CookieMonster. Both |channel_id_service| and |net_log| can be null.
   CookieMonster(scoped_refptr<PersistentCookieStore> store,
-                ChannelIDService* channel_id_service);
+                ChannelIDService* channel_id_service,
+                NetLog* net_log);
 
   // Only used during unit testing.
+  // |net_log| must outlive the CookieMonster.
   CookieMonster(scoped_refptr<PersistentCookieStore> store,
-                base::TimeDelta last_access_threshold);
+                base::TimeDelta last_access_threshold,
+                NetLog* net_log);
 
   ~CookieMonster() override;
 
@@ -213,7 +215,8 @@ class NET_EXPORT CookieMonster : public CookieStore {
  private:
   CookieMonster(scoped_refptr<PersistentCookieStore> store,
                 ChannelIDService* channel_id_service,
-                base::TimeDelta last_access_threshold);
+                base::TimeDelta last_access_threshold,
+                NetLog* net_log);
 
   // For garbage collection constants.
   FRIEND_TEST_ALL_PREFIXES(CookieMonsterTest, TestHostGarbageCollection);
@@ -617,6 +620,8 @@ class NET_EXPORT CookieMonster : public CookieStore {
   // for typical use.
   bool seen_global_task_;
 
+  NetLogWithSource net_log_;
+
   scoped_refptr<PersistentCookieStore> store_;
 
   base::Time last_time_seen_;
@@ -665,7 +670,10 @@ class NET_EXPORT CookieMonster::PersistentCookieStore
   // that are not yet returned to CookieMonster by previous priority loads.
   //
   // |loaded_callback| may not be NULL.
-  virtual void Load(const LoadedCallback& loaded_callback) = 0;
+  // |net_log| is a NetLogWithSource that may be copied if the persistent
+  // store wishes to log NetLog events.
+  virtual void Load(const LoadedCallback& loaded_callback,
+                    const NetLogWithSource& net_log) = 0;
 
   // Does a priority load of all cookies for the domain key (eTLD+1). The
   // callback will return all the cookies that are not yet returned by previous
diff --git a/chromium/net/cookies/cookie_monster_netlog_params.cc b/chromium/net/cookies/cookie_monster_netlog_params.cc
new file mode 100644
index 00000000000..e4f358c2fdf
--- /dev/null
+++ b/chromium/net/cookies/cookie_monster_netlog_params.cc
@@ -0,0 +1,100 @@
+// Copyright 2018 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/cookies/cookie_monster_netlog_params.h"
+
+#include "net/cookies/cookie_constants.h"
+#include "net/cookies/cookie_store.h"
+
+namespace net {
+
+std::unique_ptr<base::Value> NetLogCookieMonsterConstructorCallback(
+    bool persistent_store,
+    bool channel_id_service,
+    NetLogCaptureMode /* capture_mode */) {
+  std::unique_ptr<base::Value> dict =
+      std::make_unique<base::Value>(base::Value::Type::DICTIONARY);
+  dict->SetKey("persistent_store", base::Value(persistent_store));
+  dict->SetKey("channel_id_service", base::Value(channel_id_service));
+  return dict;
+}
+
+std::unique_ptr<base::Value> NetLogCookieMonsterCookieAdded(
+    const CanonicalCookie* cookie,
+    bool sync_requested,
+    NetLogCaptureMode capture_mode) {
+  if (!capture_mode.include_cookies_and_credentials())
+    return nullptr;
+
+  std::unique_ptr<base::Value> dict =
+      std::make_unique<base::Value>(base::Value::Type::DICTIONARY);
+  dict->SetKey("name", base::Value(cookie->Name()));
+  dict->SetKey("value", base::Value(cookie->Value()));
+  dict->SetKey("domain", base::Value(cookie->Domain()));
+  dict->SetKey("path", base::Value(cookie->Path()));
+  dict->SetKey("httponly", base::Value(cookie->IsHttpOnly()));
+  dict->SetKey("secure", base::Value(cookie->IsSecure()));
+  dict->SetKey("priority",
+               base::Value(CookiePriorityToString(cookie->Priority())));
+  dict->SetKey("same_site",
+               base::Value(CookieSameSiteToString(cookie->SameSite())));
+  dict->SetKey("is_persistent", base::Value(cookie->IsPersistent()));
+  dict->SetKey("sync_requested", base::Value(sync_requested));
+  return dict;
+}
+
+std::unique_ptr<base::Value> NetLogCookieMonsterCookieDeleted(
+    const CanonicalCookie* cookie,
+    CookieChangeCause cause,
+    bool sync_requested,
+    NetLogCaptureMode capture_mode) {
+  if (!capture_mode.include_cookies_and_credentials())
+    return nullptr;
+
+  std::unique_ptr<base::Value> dict =
+      std::make_unique<base::Value>(base::Value::Type::DICTIONARY);
+  dict->SetKey("name", base::Value(cookie->Name()));
+  dict->SetKey("value", base::Value(cookie->Value()));
+  dict->SetKey("domain", base::Value(cookie->Domain()));
+  dict->SetKey("path", base::Value(cookie->Path()));
+  dict->SetKey("is_persistent", base::Value(cookie->IsPersistent()));
+  dict->SetKey("deletion_cause", base::Value(CookieChangeCauseToString(cause)));
+  dict->SetKey("sync_requested", base::Value(sync_requested));
+  return dict;
+}
+
+std::unique_ptr<base::Value> NetLogCookieMonsterCookieRejectedSecure(
+    const CanonicalCookie* old_cookie,
+    const CanonicalCookie* new_cookie,
+    NetLogCaptureMode capture_mode) {
+  if (!capture_mode.include_cookies_and_credentials())
+    return nullptr;
+  std::unique_ptr<base::Value> dict =
+      std::make_unique<base::Value>(base::Value::Type::DICTIONARY);
+  dict->SetKey("name", base::Value(old_cookie->Name()));
+  dict->SetKey("domain", base::Value(old_cookie->Domain()));
+  dict->SetKey("oldpath", base::Value(old_cookie->Path()));
+  dict->SetKey("newpath", base::Value(new_cookie->Path()));
+  dict->SetKey("oldvalue", base::Value(old_cookie->Value()));
+  dict->SetKey("newvalue", base::Value(new_cookie->Value()));
+  return dict;
+}
+
+std::unique_ptr<base::Value> NetLogCookieMonsterCookieRejectedHttponly(
+    const CanonicalCookie* old_cookie,
+    const CanonicalCookie* new_cookie,
+    NetLogCaptureMode capture_mode) {
+  if (!capture_mode.include_cookies_and_credentials())
+    return nullptr;
+  std::unique_ptr<base::Value> dict =
+      std::make_unique<base::Value>(base::Value::Type::DICTIONARY);
+  dict->SetKey("name", base::Value(old_cookie->Name()));
+  dict->SetKey("domain", base::Value(old_cookie->Domain()));
+  dict->SetKey("path", base::Value(old_cookie->Path()));
+  dict->SetKey("oldvalue", base::Value(old_cookie->Value()));
+  dict->SetKey("newvalue", base::Value(new_cookie->Value()));
+  return dict;
+}
+
+}  // namespace net
diff --git a/chromium/net/cookies/cookie_monster_netlog_params.h b/chromium/net/cookies/cookie_monster_netlog_params.h
new file mode 100644
index 00000000000..fa8b0571f16
--- /dev/null
+++ b/chromium/net/cookies/cookie_monster_netlog_params.h
@@ -0,0 +1,55 @@
+// Copyright 2018 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.
+
+#ifndef NET_COOKIES_COOKIE_MONSTER_NETLOG_PARAMS_H_
+#define NET_COOKIES_COOKIE_MONSTER_NETLOG_PARAMS_H_
+
+#include <memory>
+
+#include "base/values.h"
+#include "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_change_dispatcher.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/cookies/cookie_store.h"
+#include "net/log/net_log_capture_mode.h"
+
+namespace net {
+
+// Returns a Value containing NetLog parameters for constructing
+// a CookieMonster.
+std::unique_ptr<base::Value> NetLogCookieMonsterConstructorCallback(
+    bool persistent_store,
+    bool channel_id_service,
+    NetLogCaptureMode capture_mode);
+
+// Returns a Value containing NetLog parameters for adding a cookie.
+std::unique_ptr<base::Value> NetLogCookieMonsterCookieAdded(
+    const CanonicalCookie* cookie,
+    bool sync_requested,
+    NetLogCaptureMode capture_mode);
+
+// Returns a Value containing NetLog parameters for deleting a cookie.
+std::unique_ptr<base::Value> NetLogCookieMonsterCookieDeleted(
+    const CanonicalCookie* cookie,
+    CookieChangeCause cause,
+    bool sync_requested,
+    NetLogCaptureMode capture_mode);
+
+// Returns a Value containing NetLog parameters for when a cookie addition
+// is rejected because of a conflict with a secure cookie.
+std::unique_ptr<base::Value> NetLogCookieMonsterCookieRejectedSecure(
+    const CanonicalCookie* old_cookie,
+    const CanonicalCookie* new_cookie,
+    NetLogCaptureMode capture_mode);
+
+// Returns a Value containing NetLog parameters for when a cookie addition
+// is rejected because of a conflict with an httponly cookie.
+std::unique_ptr<base::Value> NetLogCookieMonsterCookieRejectedHttponly(
+    const CanonicalCookie* old_cookie,
+    const CanonicalCookie* new_cookie,
+    NetLogCaptureMode capture_mode);
+
+}  // namespace net
+
+#endif  // NET_COOKIES_COOKIE_MONSTER_NETLOG_PARAMS_H_
diff --git a/chromium/net/cookies/cookie_monster_perftest.cc b/chromium/net/cookies/cookie_monster_perftest.cc
index b6afc0a1403..38c5fdcbfa9 100644
--- a/chromium/net/cookies/cookie_monster_perftest.cc
+++ b/chromium/net/cookies/cookie_monster_perftest.cc
@@ -135,7 +135,7 @@ TEST(ParsedCookieTest, TestParseBigCookies) {
 }
 
 TEST_F(CookieMonsterTest, TestAddCookiesOnSingleHost) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  auto cm = std::make_unique<CookieMonster>(nullptr, nullptr, nullptr);
   std::vector<std::string> cookies;
   for (int i = 0; i < kNumCookies; i++) {
     cookies.push_back(base::StringPrintf("a%03d=b", i));
@@ -168,7 +168,7 @@ TEST_F(CookieMonsterTest, TestAddCookiesOnSingleHost) {
 }
 
 TEST_F(CookieMonsterTest, TestAddCookieOnManyHosts) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  auto cm = std::make_unique<CookieMonster>(nullptr, nullptr, nullptr);
   std::string cookie(kCookieLine);
   std::vector<GURL> gurls;  // just wanna have ffffuunnn
   for (int i = 0; i < kNumCookies; ++i) {
@@ -201,7 +201,7 @@ TEST_F(CookieMonsterTest, TestAddCookieOnManyHosts) {
 }
 
 TEST_F(CookieMonsterTest, TestDomainTree) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  auto cm = std::make_unique<CookieMonster>(nullptr, nullptr, nullptr);
   GetCookieListCallback getCookieListCallback;
   SetCookieCallback setCookieCallback;
   const char domain_cookie_format_tree[] = "a=b; domain=%s";
@@ -257,7 +257,7 @@ TEST_F(CookieMonsterTest, TestDomainTree) {
 }
 
 TEST_F(CookieMonsterTest, TestDomainLine) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  auto cm = std::make_unique<CookieMonster>(nullptr, nullptr, nullptr);
   SetCookieCallback setCookieCallback;
   GetCookieListCallback getCookieListCallback;
   std::vector<std::string> domain_list;
@@ -318,7 +318,8 @@ TEST_F(CookieMonsterTest, TestImport) {
 
   store->SetLoadExpectation(true, std::move(initial_cookies));
 
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, nullptr));
 
   // Import will happen on first access.
   GURL gurl("www.foo.com");
@@ -332,7 +333,8 @@ TEST_F(CookieMonsterTest, TestImport) {
 }
 
 TEST_F(CookieMonsterTest, TestGetKey) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, nullptr));
   base::PerfTimeLogger timer("Cookie_monster_get_key");
   for (int i = 0; i < kNumCookies; i++)
     cm->GetKey("www.foo.com");
diff --git a/chromium/net/cookies/cookie_monster_store_test.cc b/chromium/net/cookies/cookie_monster_store_test.cc
index 66f1812e03f..4c7d7c404bc 100644
--- a/chromium/net/cookies/cookie_monster_store_test.cc
+++ b/chromium/net/cookies/cookie_monster_store_test.cc
@@ -42,7 +42,8 @@ void MockPersistentCookieStore::SetLoadExpectation(
   load_result_.swap(result);
 }
 
-void MockPersistentCookieStore::Load(const LoadedCallback& loaded_callback) {
+void MockPersistentCookieStore::Load(const LoadedCallback& loaded_callback,
+                                     const NetLogWithSource& /* net_log */) {
   if (store_load_commands_) {
     commands_.push_back(
         CookieStoreCommand(CookieStoreCommand::LOAD, loaded_callback, ""));
@@ -66,7 +67,7 @@ void MockPersistentCookieStore::LoadCookiesForKey(
     return;
   }
   if (!loaded_) {
-    Load(loaded_callback);
+    Load(loaded_callback, NetLogWithSource());
   } else {
     std::vector<std::unique_ptr<CanonicalCookie>> empty_cookies;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ -86,6 +87,8 @@ void MockPersistentCookieStore::DeleteCookie(const CanonicalCookie& cookie) {
   commands_.push_back(CookieStoreCommand(CookieStoreCommand::REMOVE, cookie));
 }
 
+void MockPersistentCookieStore::SetForceKeepSessionState() {}
+
 void MockPersistentCookieStore::SetBeforeFlushCallback(
     base::RepeatingClosure callback) {}
 
@@ -95,9 +98,6 @@ void MockPersistentCookieStore::Flush(base::OnceClosure callback) {
                                                   std::move(callback));
 }
 
-void MockPersistentCookieStore::SetForceKeepSessionState() {
-}
-
 MockPersistentCookieStore::~MockPersistentCookieStore() = default;
 
 std::unique_ptr<CanonicalCookie> BuildCanonicalCookie(
@@ -139,7 +139,8 @@ MockSimplePersistentCookieStore::MockSimplePersistentCookieStore()
 }
 
 void MockSimplePersistentCookieStore::Load(
-    const LoadedCallback& loaded_callback) {
+    const LoadedCallback& loaded_callback,
+    const NetLogWithSource& /* net_log */) {
   std::vector<std::unique_ptr<CanonicalCookie>> out_cookies;
 
   for (auto it = cookies_.begin(); it != cookies_.end(); it++)
@@ -154,7 +155,7 @@ void MockSimplePersistentCookieStore::LoadCookiesForKey(
     const std::string& key,
     const LoadedCallback& loaded_callback) {
   if (!loaded_) {
-    Load(loaded_callback);
+    Load(loaded_callback, NetLogWithSource());
   } else {
     std::vector<std::unique_ptr<CanonicalCookie>> empty_cookies;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ -183,6 +184,8 @@ void MockSimplePersistentCookieStore::DeleteCookie(
   cookies_.erase(it);
 }
 
+void MockSimplePersistentCookieStore::SetForceKeepSessionState() {}
+
 void MockSimplePersistentCookieStore::SetBeforeFlushCallback(
     base::RepeatingClosure callback) {}
 
@@ -192,9 +195,6 @@ void MockSimplePersistentCookieStore::Flush(base::OnceClosure callback) {
                                                   std::move(callback));
 }
 
-void MockSimplePersistentCookieStore::SetForceKeepSessionState() {
-}
-
 std::unique_ptr<CookieMonster> CreateMonsterFromStoreForGC(
     int num_secure_cookies,
     int num_old_secure_cookies,
@@ -238,7 +238,7 @@ std::unique_ptr<CookieMonster> CreateMonsterFromStoreForGC(
     store->AddCookie(*cc);
   }
 
-  return std::make_unique<CookieMonster>(store.get());
+  return std::make_unique<CookieMonster>(store.get(), nullptr, nullptr);
 }
 
 MockSimplePersistentCookieStore::~MockSimplePersistentCookieStore() = default;
diff --git a/chromium/net/cookies/cookie_monster_store_test.h b/chromium/net/cookies/cookie_monster_store_test.h
index 05bdb93dcc6..79f0d12f0cf 100644
--- a/chromium/net/cookies/cookie_monster_store_test.h
+++ b/chromium/net/cookies/cookie_monster_store_test.h
@@ -21,6 +21,7 @@
 #include "base/macros.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_monster.h"
+#include "net/log/net_log_with_source.h"
 
 class GURL;
 
@@ -88,7 +89,8 @@ class MockPersistentCookieStore : public CookieMonster::PersistentCookieStore {
 
   const CommandList& commands() const { return commands_; }
 
-  void Load(const LoadedCallback& loaded_callback) override;
+  void Load(const LoadedCallback& loaded_callback,
+            const NetLogWithSource& net_log) override;
 
   void LoadCookiesForKey(const std::string& key,
                          const LoadedCallback& loaded_callback) override;
@@ -99,12 +101,12 @@ class MockPersistentCookieStore : public CookieMonster::PersistentCookieStore {
 
   void DeleteCookie(const CanonicalCookie& cookie) override;
 
+  void SetForceKeepSessionState() override;
+
   void SetBeforeFlushCallback(base::RepeatingClosure callback) override;
 
   void Flush(base::OnceClosure callback) override;
 
-  void SetForceKeepSessionState() override;
-
  protected:
   ~MockPersistentCookieStore() override;
 
@@ -143,7 +145,8 @@ class MockSimplePersistentCookieStore
  public:
   MockSimplePersistentCookieStore();
 
-  void Load(const LoadedCallback& loaded_callback) override;
+  void Load(const LoadedCallback& loaded_callback,
+            const NetLogWithSource& net_log) override;
 
   void LoadCookiesForKey(const std::string& key,
                          const LoadedCallback& loaded_callback) override;
@@ -154,12 +157,12 @@ class MockSimplePersistentCookieStore
 
   void DeleteCookie(const CanonicalCookie& cookie) override;
 
+  void SetForceKeepSessionState() override;
+
   void SetBeforeFlushCallback(base::RepeatingClosure callback) override;
 
   void Flush(base::OnceClosure callback) override;
 
-  void SetForceKeepSessionState() override;
-
  protected:
   ~MockSimplePersistentCookieStore() override;
 
diff --git a/chromium/net/cookies/cookie_monster_unittest.cc b/chromium/net/cookies/cookie_monster_unittest.cc
index 6496003ae9b..ecedc2285a1 100644
--- a/chromium/net/cookies/cookie_monster_unittest.cc
+++ b/chromium/net/cookies/cookie_monster_unittest.cc
@@ -40,6 +40,9 @@
 #include "net/cookies/cookie_store_unittest.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
+#include "net/log/net_log_with_source.h"
+#include "net/log/test_net_log.h"
+#include "net/log/test_net_log_util.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -59,7 +62,9 @@ namespace {
 class NewMockPersistentCookieStore
     : public CookieMonster::PersistentCookieStore {
  public:
-  MOCK_METHOD1(Load, void(const LoadedCallback& loaded_callback));
+  MOCK_METHOD2(Load,
+               void(const LoadedCallback& loaded_callback,
+                    const NetLogWithSource& net_log));
   MOCK_METHOD2(LoadCookiesForKey,
                void(const std::string& key,
                     const LoadedCallback& loaded_callback));
@@ -91,7 +96,9 @@ const char kOtherDomain[] = "http://www.mit.edu";
 
 struct CookieMonsterTestTraits {
   static std::unique_ptr<CookieStore> Create() {
-    return std::make_unique<CookieMonster>(nullptr);
+    return std::make_unique<CookieMonster>(nullptr /* store */,
+                                           nullptr /* channel_id_service */,
+                                           nullptr /* netlog */);
   }
 
   static void DeliverChangeNotifications() { base::RunLoop().RunUntilIdle(); }
@@ -358,7 +365,7 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
         (domain_max_cookies + domain_purge_cookies) * 2;
     // Add a bunch of cookies on a single host, should purge them.
     {
-      std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+      auto cm = std::make_unique<CookieMonster>(nullptr, nullptr, &net_log_);
       for (int i = 0; i < more_than_enough_cookies; ++i) {
         std::string cookie = base::StringPrintf("a%03d=b", i);
         EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), cookie));
@@ -375,7 +382,7 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
     // between them.  We shouldn't go above kDomainMaxCookies for both together.
     GURL url_google_specific(http_www_foo_.Format("http://www.gmail.%D"));
     {
-      std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+      auto cm = std::make_unique<CookieMonster>(nullptr, nullptr, &net_log_);
       for (int i = 0; i < more_than_enough_cookies; ++i) {
         std::string cookie_general = base::StringPrintf("a%03d=b", i);
         EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), cookie_general));
@@ -552,7 +559,7 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
     std::unique_ptr<CookieMonster> cm;
 
     if (alt_host_entries == nullptr) {
-      cm.reset(new CookieMonster(nullptr));
+      cm.reset(new CookieMonster(nullptr, nullptr, &net_log_));
     } else {
       // When generating all of these cookies on alternate hosts, they need to
       // be all older than the max "safe" date for GC, which is currently 30
@@ -597,7 +604,7 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
     DCHECK_EQ(150U, CookieMonster::kDomainMaxCookies -
                         CookieMonster::kDomainPurgeCookies);
 
-    std::unique_ptr<CookieMonster> cm(new CookieMonster(NULL));
+    auto cm = std::make_unique<CookieMonster>(nullptr, nullptr, &net_log_);
 
     // Each test case adds 181 cookies, so 31 cookies are evicted.
     // Cookie same priority, repeated for each priority.
@@ -660,7 +667,7 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
     DCHECK_EQ(150U, CookieMonster::kDomainMaxCookies -
                         CookieMonster::kDomainPurgeCookies);
 
-    std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+    auto cm = std::make_unique<CookieMonster>(nullptr, nullptr, &net_log_);
 
     // Each test case adds 181 cookies, so 31 cookies are evicted.
     // Cookie same priority, repeated for each priority.
@@ -717,7 +724,7 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
     DCHECK_EQ(150U, CookieMonster::kDomainMaxCookies -
                         CookieMonster::kDomainPurgeCookies);
 
-    std::unique_ptr<CookieMonster> cm(new CookieMonster(NULL));
+    auto cm = std::make_unique<CookieMonster>(nullptr, nullptr, &net_log_);
 
     // Each test case adds 180 secure cookies, and some non-secure cookie. The
     // secure cookies take priority, so the non-secure cookie is removed, along
@@ -823,7 +830,7 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
   // Function for creating a CM with a number of cookies in it,
   // no store (and hence no ability to affect access time).
   CookieMonster* CreateMonsterForGC(int num_cookies) {
-    CookieMonster* cm(new CookieMonster(NULL));
+    CookieMonster* cm(new CookieMonster(nullptr, nullptr, &net_log_));
     for (int i = 0; i < num_cookies; i++) {
       SetCookie(cm, GURL(base::StringPrintf("http://h%05d.izzle", i)), "a=1");
     }
@@ -846,6 +853,7 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
 
     return false;
   }
+  TestNetLog net_log_;
 };
 
 using CookieMonsterTest = CookieMonsterTestBase<CookieMonsterTestTraits>;
@@ -945,7 +953,8 @@ class DeferredCookieTaskTest : public CookieMonsterTest {
  protected:
   DeferredCookieTaskTest() : expect_load_called_(false) {
     persistent_store_ = new NewMockPersistentCookieStore();
-    cookie_monster_.reset(new CookieMonster(persistent_store_.get()));
+    cookie_monster_ = std::make_unique<CookieMonster>(persistent_store_.get(),
+                                                      nullptr, &net_log_);
   }
 
   // Defines a cookie to be returned from PersistentCookieStore::Load
@@ -998,7 +1007,7 @@ class DeferredCookieTaskTest : public CookieMonsterTest {
     // Make sure the |load_run_loop_| is not reused.
     CHECK(!expect_load_called_);
     expect_load_called_ = true;
-    EXPECT_CALL(*persistent_store_.get(), Load(testing::_))
+    EXPECT_CALL(*persistent_store_.get(), Load(testing::_, testing::_))
         .WillOnce(testing::DoAll(testing::SaveArg<0>(&loaded_callback_),
                                  QuitRunLoop(&load_run_loop_)));
   }
@@ -1339,7 +1348,8 @@ TEST_F(DeferredCookieTaskTest, DeferredTaskOrder) {
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
   CookieOptions options;
   options.set_include_httponly();
 
@@ -1370,7 +1380,8 @@ TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedInTimeRangeTimestamps) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
   Time now = Time::Now();
 
   // Nothing has been added so nothing should be deleted.
@@ -1417,7 +1428,8 @@ TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedInTimeRangeTimestamps) {
 
 TEST_F(CookieMonsterTest,
        TestCookieDeleteAllCreatedInTimeRangeTimestampsWithInfo) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
   Time now = Time::Now();
 
   CanonicalCookie test_cookie;
@@ -1473,7 +1485,7 @@ static const base::TimeDelta kAccessDelay =
 
 TEST_F(CookieMonsterTest, TestLastAccess) {
   std::unique_ptr<CookieMonster> cm(
-      new CookieMonster(nullptr, kLastAccessThreshold));
+      new CookieMonster(nullptr, kLastAccessThreshold, &net_log_));
 
   EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=B"));
   const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
@@ -1527,8 +1539,10 @@ TEST_F(CookieMonsterTest, TestPriorityAwareGarbageCollectionMixed) {
 }
 
 TEST_F(CookieMonsterTest, SetCookieableSchemes) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
-  std::unique_ptr<CookieMonster> cm_foo(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
+  std::unique_ptr<CookieMonster> cm_foo(
+      new CookieMonster(nullptr, nullptr, &net_log_));
 
   // Only cm_foo should allow foo:// cookies.
   std::vector<std::string> schemes;
@@ -1546,7 +1560,7 @@ TEST_F(CookieMonsterTest, SetCookieableSchemes) {
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
   std::unique_ptr<CookieMonster> cm(
-      new CookieMonster(nullptr, kLastAccessThreshold));
+      new CookieMonster(nullptr, kLastAccessThreshold, &net_log_));
 
   // Create an httponly cookie.
   CookieOptions options;
@@ -1613,7 +1627,8 @@ TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
 }
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
   CookieOptions options;
 
   EXPECT_TRUE(SetCookieWithOptions(cm.get(), www_foo_foo_.url(),
@@ -1651,7 +1666,8 @@ TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
 }
 
 TEST_F(CookieMonsterTest, CookieSorting) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
 
   EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "B=B1; path=/"));
   EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "B=B2; path=/foo"));
@@ -1675,7 +1691,8 @@ TEST_F(CookieMonsterTest, CookieSorting) {
 }
 
 TEST_F(CookieMonsterTest, InheritCreationDate) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
 
   base::Time the_not_so_distant_past(base::Time::Now() -
                                      base::TimeDelta::FromSeconds(1000));
@@ -1705,7 +1722,8 @@ TEST_F(CookieMonsterTest, InheritCreationDate) {
 }
 
 TEST_F(CookieMonsterTest, DeleteCookieByName) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
 
   EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=A1; path=/"));
   EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=A2; path=/foo"));
@@ -1781,7 +1799,8 @@ TEST_F(CookieMonsterTest, DontImportDuplicateCookies) {
   // Inject our initial cookies into the mock PersistentCookieStore.
   store->SetLoadExpectation(true, std::move(initial_cookies));
 
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
 
   // Verify that duplicates were not imported for path "/".
   // (If this had failed, GetCookies() would have also returned X=1, X=2, X=4).
@@ -1837,7 +1856,8 @@ TEST_F(CookieMonsterTest, ImportDuplicateCreationTimes) {
   // Inject our initial cookies into the mock PersistentCookieStore.
   store->SetLoadExpectation(true, std::move(initial_cookies));
 
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
 
   CookieList list(GetAllCookies(cm.get()));
   EXPECT_EQ(2U, list.size());
@@ -1850,7 +1870,8 @@ TEST_F(CookieMonsterTest, ImportDuplicateCreationTimes) {
 }
 
 TEST_F(CookieMonsterTest, PredicateSeesAllCookies) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
   PopulateCmForPredicateCheck(cm.get());
   // We test that we can see all cookies with |delete_info|. This includes
   // host, http_only, host secure, and all domain cookies.
@@ -1870,7 +1891,8 @@ TEST_F(CookieMonsterTest, PredicateSeesAllCookies) {
 }
 
 TEST_F(CookieMonsterTest, UniqueCreationTime) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
   CookieOptions options;
 
   // Add in three cookies through every public interface to the
@@ -1920,7 +1942,8 @@ TEST_F(CookieMonsterTest, UniqueCreationTime) {
 // Mainly a test of GetEffectiveDomain, or more specifically, of the
 // expected behavior of GetEffectiveDomain within the CookieMonster.
 TEST_F(CookieMonsterTest, GetKey) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
 
   // This test is really only interesting if GetKey() actually does something.
   EXPECT_EQ("foo.com", cm->GetKey("www.foo.com"));
@@ -1964,7 +1987,8 @@ TEST_F(CookieMonsterTest, BackingStoreCommunication) {
 
   // Create new cookies and flush them to the store.
   {
-    std::unique_ptr<CookieMonster> cmout(new CookieMonster(store.get()));
+    std::unique_ptr<CookieMonster> cmout(
+        new CookieMonster(store.get(), nullptr, &net_log_));
     for (const auto& cookie : input_info) {
       EXPECT_TRUE(SetCanonicalCookie(
           cmout.get(),
@@ -1982,7 +2006,8 @@ TEST_F(CookieMonsterTest, BackingStoreCommunication) {
 
   // Create a new cookie monster and make sure that everything is correct
   {
-    std::unique_ptr<CookieMonster> cmin(new CookieMonster(store.get()));
+    std::unique_ptr<CookieMonster> cmin(
+        new CookieMonster(store.get(), nullptr, &net_log_));
     CookieList cookies(GetAllCookies(cmin.get()));
     ASSERT_EQ(2u, cookies.size());
     // Ordering is path length, then creation time.  So second cookie
@@ -2016,7 +2041,7 @@ TEST_F(CookieMonsterTest, RestoreDifferentCookieSameCreationTime) {
       base::MakeRefCounted<MockPersistentCookieStore>();
 
   {
-    CookieMonster cmout(store.get());
+    CookieMonster cmout(store.get(), nullptr, &net_log_);
     GURL url("http://www.example.com/");
     EXPECT_TRUE(
         SetCookieWithCreationTime(&cmout, url, "A=1; max-age=600", current));
@@ -2038,7 +2063,7 @@ TEST_F(CookieMonsterTest, RestoreDifferentCookieSameCreationTime) {
 
   // Now read them in. Should get two cookies, not one.
   {
-    CookieMonster cmin(store2.get());
+    CookieMonster cmin(store2.get(), nullptr, &net_log_);
     CookieList cookies(GetAllCookies(&cmin));
     ASSERT_EQ(2u, cookies.size());
   }
@@ -2047,7 +2072,8 @@ TEST_F(CookieMonsterTest, RestoreDifferentCookieSameCreationTime) {
 TEST_F(CookieMonsterTest, CookieListOrdering) {
   // Put a random set of cookies into a monster and make sure
   // they're returned in the right order.
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
   EXPECT_TRUE(
       SetCookie(cm.get(), GURL("http://d.c.b.a.foo.com/aa/x.html"), "c=1"));
   EXPECT_TRUE(SetCookie(cm.get(), GURL("http://b.a.foo.com/aa/bb/cc/x.html"),
@@ -2182,7 +2208,8 @@ TEST_F(CookieMonsterTest, WhileLoadingLoadCompletesBeforeKeyLoadCompletes) {
 
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   store->set_store_load_commands(true);
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
 
   // Get all cookies task that queues a task to set a cookie when executed.
   ResultSavingCookieCallback<bool> set_cookie_callback;
@@ -2236,7 +2263,8 @@ TEST_F(CookieMonsterTest, WhileLoadingDeleteAllGetForURL) {
 
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   store->set_store_load_commands(true);
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
 
   ResultSavingCookieCallback<uint32_t> delete_callback;
   cm->DeleteAllAsync(base::Bind(&ResultSavingCookieCallback<uint32_t>::Run,
@@ -2276,7 +2304,8 @@ TEST_F(CookieMonsterTest, WhileLoadingGetAllSetGetAll) {
 
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   store->set_store_load_commands(true);
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
 
   GetCookieListCallback get_cookie_list_callback1;
   cm->GetAllCookiesAsync(
@@ -2329,7 +2358,8 @@ TEST_F(CookieMonsterTest, CheckOrderOfCookieTaskQueueWhenLoadingCompletes) {
 
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   store->set_store_load_commands(true);
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
 
   // Get all cookies task that queues a task to set a cookie when executed.
   ResultSavingCookieCallback<bool> set_cookie_callback;
@@ -2375,7 +2405,7 @@ TEST_F(CookieMonsterTest, CheckOrderOfCookieTaskQueueWhenLoadingCompletes) {
 TEST_F(CookieMonsterTest, FlushStore) {
   auto counter = base::MakeRefCounted<CallbackCounter>();
   auto store = base::MakeRefCounted<FlushablePersistentStore>();
-  auto cm = std::make_unique<CookieMonster>(store);
+  auto cm = std::make_unique<CookieMonster>(store, nullptr, &net_log_);
 
   ASSERT_EQ(0, store->flush_count());
   ASSERT_EQ(0, counter->callback_count());
@@ -2410,7 +2440,7 @@ TEST_F(CookieMonsterTest, FlushStore) {
   ASSERT_EQ(2, counter->callback_count());
 
   // If there's no backing store, FlushStore() is always a safe no-op.
-  cm.reset(new CookieMonster(nullptr));
+  cm.reset(new CookieMonster(nullptr, nullptr, &net_log_));
   GetAllCookies(cm.get());  // Force init.
   cm->FlushStore(base::DoNothing());
   base::RunLoop().RunUntilIdle();
@@ -2434,12 +2464,12 @@ TEST_F(CookieMonsterTest, SetBeforeFlushCallbackIsCalled) {
   EXPECT_CALL(*store, SetBeforeFlushCallback(testing::_)).Times(2);
 
   std::unique_ptr<CookieMonster> cm(
-      new CookieMonster(store.get(), channel_id_service.get()));
+      new CookieMonster(store.get(), channel_id_service.get(), &net_log_));
 }
 
 TEST_F(CookieMonsterTest, SetAllCookies) {
   scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore());
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  auto cm = std::make_unique<CookieMonster>(store.get(), nullptr, &net_log_);
   cm->SetPersistSessionCookies(true);
 
   EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "U=V; path=/"));
@@ -2482,13 +2512,27 @@ TEST_F(CookieMonsterTest, SetAllCookies) {
   ASSERT_TRUE(++it != cookies.end());
   EXPECT_EQ("Y", it->Name());
   EXPECT_EQ("Z", it->Value());
+
+  cm = nullptr;
+  TestNetLogEntry::List entries;
+  net_log_.GetEntries(&entries);
+  size_t pos = ExpectLogContainsSomewhere(
+      entries, 0, NetLogEventType::COOKIE_STORE_ALIVE, NetLogEventPhase::BEGIN);
+  pos = ExpectLogContainsSomewhere(
+      entries, pos, NetLogEventType::COOKIE_STORE_SESSION_PERSISTENCE,
+      NetLogEventPhase::NONE);
+  pos = ExpectLogContainsSomewhere(entries, pos,
+                                   NetLogEventType::COOKIE_STORE_COOKIE_ADDED,
+                                   NetLogEventPhase::NONE);
+  ExpectLogContainsSomewhere(entries, pos, NetLogEventType::COOKIE_STORE_ALIVE,
+                             NetLogEventPhase::END);
 }
 
 // Check that DeleteAll does flush (as a sanity check that flush_count()
 // works).
 TEST_F(CookieMonsterTest, DeleteAll) {
   scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore());
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  auto cm = std::make_unique<CookieMonster>(store.get(), nullptr, &net_log_);
   cm->SetPersistSessionCookies(true);
 
   EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "X=Y; path=/"));
@@ -2496,10 +2540,28 @@ TEST_F(CookieMonsterTest, DeleteAll) {
   ASSERT_EQ(0, store->flush_count());
   EXPECT_EQ(1u, DeleteAll(cm.get()));
   EXPECT_EQ(1, store->flush_count());
+
+  cm = nullptr;
+  TestNetLogEntry::List entries;
+  net_log_.GetEntries(&entries);
+  size_t pos = ExpectLogContainsSomewhere(
+      entries, 0, NetLogEventType::COOKIE_STORE_ALIVE, NetLogEventPhase::BEGIN);
+  pos = ExpectLogContainsSomewhere(
+      entries, pos, NetLogEventType::COOKIE_STORE_SESSION_PERSISTENCE,
+      NetLogEventPhase::NONE);
+  pos = ExpectLogContainsSomewhere(entries, pos,
+                                   NetLogEventType::COOKIE_STORE_COOKIE_ADDED,
+                                   NetLogEventPhase::NONE);
+  pos = ExpectLogContainsSomewhere(entries, pos,
+                                   NetLogEventType::COOKIE_STORE_COOKIE_DELETED,
+                                   NetLogEventPhase::NONE);
+  ExpectLogContainsSomewhere(entries, pos, NetLogEventType::COOKIE_STORE_ALIVE,
+                             NetLogEventPhase::END);
 }
 
 TEST_F(CookieMonsterTest, HistogramCheck) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
   // Should match call in InitializeHistograms, but doesn't really matter
   // since the histogram should have been initialized by the CM construction
   // above.
@@ -2541,7 +2603,8 @@ TEST_F(CookieMonsterTest, InvalidExpiryTime) {
 // CookieStore if the "persist session cookies" option is on.
 TEST_F(CookieMonsterTest, PersistSessionCookies) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
   cm->SetPersistSessionCookies(true);
 
   // All cookies set with SetCookie are session cookies.
@@ -2577,7 +2640,8 @@ TEST_F(CookieMonsterTest, PersistSessionCookies) {
 // Test the commands sent to the persistent cookie store.
 TEST_F(CookieMonsterTest, PersisentCookieStorageTest) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
 
   // Add a cookie.
   EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(),
@@ -2646,7 +2710,8 @@ TEST_F(CookieMonsterTest, ControlCharacterPurge) {
   // Inject our initial cookies into the mock PersistentCookieStore.
   store->SetLoadExpectation(true, std::move(initial_cookies));
 
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
 
   EXPECT_EQ("foo=bar; hello=world", GetCookies(cm.get(), url));
 }
@@ -2657,7 +2722,8 @@ TEST_F(CookieMonsterTest, CookieSourceHistogram) {
   const std::string cookie_source_histogram = "Cookie.CookieSourceScheme";
 
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
 
   histograms.ExpectTotalCount(cookie_source_histogram, 0);
 
@@ -2719,7 +2785,8 @@ TEST_F(CookieMonsterTest, CookieDeleteEquivalentHistogramTest) {
   const std::string cookie_source_histogram = "Cookie.CookieDeleteEquivalent";
 
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get()));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(store.get(), nullptr, &net_log_));
 
   // Set a secure cookie from a secure origin
   EXPECT_TRUE(SetCookie(cm.get(), https_www_foo_.url(), "A=B; Secure"));
@@ -2759,6 +2826,12 @@ TEST_F(CookieMonsterTest, CookieDeleteEquivalentHistogramTest) {
       cookie_source_histogram,
       CookieMonster::COOKIE_DELETE_EQUIVALENT_WOULD_HAVE_DELETED, 1);
 
+  TestNetLogEntry::List entries;
+  net_log_.GetEntries(&entries);
+  ExpectLogContainsSomewhere(
+      entries, 0, NetLogEventType::COOKIE_STORE_COOKIE_REJECTED_SECURE,
+      NetLogEventPhase::NONE);
+
   // Set a non-secure cookie from an insecure origin that matches the name of an
   // already existing cookie but is not equivalent. This should fail since it's
   // trying to shadow a secure cookie.
@@ -2811,7 +2884,8 @@ TEST_F(CookieMonsterTest, CookieDeleteEquivalentHistogramTest) {
 }
 
 TEST_F(CookieMonsterTest, SetSecureCookies) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, &net_log_));
   GURL http_url("http://www.foo.com");
   GURL http_superdomain_url("http://foo.com");
   GURL https_url("https://www.foo.com");
@@ -2881,6 +2955,12 @@ TEST_F(CookieMonsterTest, SetSecureCookies) {
   // Note that the lack of an explicit options object below uses the default,
   // which in this case includes "exclude_httponly = true".
   EXPECT_FALSE(SetCookie(cm.get(), https_url, "C=E; Secure"));
+
+  TestNetLogEntry::List entries;
+  net_log_.GetEntries(&entries);
+  ExpectLogContainsSomewhere(
+      entries, 0, NetLogEventType::COOKIE_STORE_COOKIE_REJECTED_HTTPONLY,
+      NetLogEventPhase::NONE);
 }
 
 // Tests for behavior for strict secure cookies.
@@ -3008,7 +3088,8 @@ TEST_F(CookieMonsterTest, EvictSecureCookies) {
 // Tests that strict secure cookies doesn't trip equivalent cookie checks
 // accidentally. Regression test for https://crbug.com/569943.
 TEST_F(CookieMonsterTest, EquivalentCookies) {
-  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr));
+  std::unique_ptr<CookieMonster> cm(
+      new CookieMonster(nullptr, nullptr, nullptr));
   GURL http_url("http://www.foo.com");
   GURL http_superdomain_url("http://foo.com");
   GURL https_url("https://www.foo.com");
@@ -3031,7 +3112,7 @@ TEST_F(CookieMonsterTest, SetCanonicalCookieDoesNotBlockForLoadAll) {
       base::MakeRefCounted<MockPersistentCookieStore>();
   // Collect load commands so we have control over their execution.
   persistent_store->set_store_load_commands(true);
-  CookieMonster cm(persistent_store.get());
+  CookieMonster cm(persistent_store.get(), nullptr, nullptr);
 
   // Start of a canonical cookie set.
   ResultSavingCookieCallback<bool> callback_set;
@@ -3077,7 +3158,7 @@ TEST_F(CookieMonsterTest, DeleteDuplicateCTime) {
   // that the implementation doesn't just happen to pick the right one because
   // of implementation details.
   for (size_t run = 0; run < base::size(kNames); ++run) {
-    CookieMonster cm(nullptr);
+    CookieMonster cm(nullptr, nullptr, nullptr);
     Time now = Time::Now();
     GURL url("http://www.example.com");
 
@@ -3113,7 +3194,7 @@ class CookieMonsterNotificationTest : public CookieMonsterTest {
   CookieMonsterNotificationTest()
       : test_url_("http://www.foo.com/foo"),
         store_(new MockPersistentCookieStore),
-        monster_(new CookieMonster(store_.get())) {}
+        monster_(new CookieMonster(store_.get(), nullptr, nullptr)) {}
 
   ~CookieMonsterNotificationTest() override = default;
 
@@ -3144,8 +3225,7 @@ TEST_F(CookieMonsterNotificationTest, GlobalNotBroadcast) {
   store->set_store_load_commands(true);
 
   // Bind it to a CookieMonster
-  std::unique_ptr<CookieMonster> monster(
-      std::make_unique<CookieMonster>(store.get()));
+  auto monster = std::make_unique<CookieMonster>(store.get(), nullptr, nullptr);
 
   // Trigger load dispatch and confirm it.
   monster->GetAllCookiesAsync(CookieStore::GetCookieListCallback());
diff --git a/chromium/net/cookies/cookie_store_test_helpers.cc b/chromium/net/cookies/cookie_store_test_helpers.cc
index 64ab30def9b..4577dfd4208 100644
--- a/chromium/net/cookies/cookie_store_test_helpers.cc
+++ b/chromium/net/cookies/cookie_store_test_helpers.cc
@@ -64,7 +64,9 @@ DelayedCookieMonsterChangeDispatcher::AddCallbackForAllChanges(
 }
 
 DelayedCookieMonster::DelayedCookieMonster()
-    : cookie_monster_(new CookieMonster(nullptr, nullptr)),
+    : cookie_monster_(new CookieMonster(nullptr /* store */,
+                                        nullptr /* channel_id_service */,
+                                        nullptr /* netlog */)),
       did_run_(false),
       result_(false) {}
 
@@ -230,7 +232,8 @@ std::string CookieURLHelper::Format(const std::string& format_string) const {
 //
 FlushablePersistentStore::FlushablePersistentStore() : flush_count_(0) {}
 
-void FlushablePersistentStore::Load(const LoadedCallback& loaded_callback) {
+void FlushablePersistentStore::Load(const LoadedCallback& loaded_callback,
+                                    const NetLogWithSource& /* net_log */) {
   std::vector<std::unique_ptr<CanonicalCookie>> out_cookies;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(loaded_callback, std::move(out_cookies)));
@@ -239,7 +242,7 @@ void FlushablePersistentStore::Load(const LoadedCallback& loaded_callback) {
 void FlushablePersistentStore::LoadCookiesForKey(
     const std::string& key,
     const LoadedCallback& loaded_callback) {
-  Load(loaded_callback);
+  Load(loaded_callback, NetLogWithSource());
 }
 
 void FlushablePersistentStore::AddCookie(const CanonicalCookie&) {}
diff --git a/chromium/net/cookies/cookie_store_test_helpers.h b/chromium/net/cookies/cookie_store_test_helpers.h
index 496a24f9f0a..8527b69e70c 100644
--- a/chromium/net/cookies/cookie_store_test_helpers.h
+++ b/chromium/net/cookies/cookie_store_test_helpers.h
@@ -14,6 +14,7 @@
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
 #include "net/cookies/cookie_change_dispatcher.h"
+#include "net/log/net_log_with_source.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class GURL;
@@ -151,7 +152,8 @@ class FlushablePersistentStore : public CookieMonster::PersistentCookieStore {
   FlushablePersistentStore();
 
   // CookieMonster::PersistentCookieStore implementation:
-  void Load(const LoadedCallback& loaded_callback) override;
+  void Load(const LoadedCallback& loaded_callback,
+            const NetLogWithSource& net_log) override;
   void LoadCookiesForKey(const std::string& key,
                          const LoadedCallback& loaded_callback) override;
   void AddCookie(const CanonicalCookie&) override;