Update from https://crrev.com/316786

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 39 matching lines @@
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
+#include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.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"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
@@ skipping 1366 matching lines @@
 
 void CookieMonster::InitStore() {
   DCHECK(store_.get()) << "Store must exist to initialize";
 
   // We bind in the current time so that we can report the wall-clock time for
   // loading cookies.
   store_->Load(base::Bind(&CookieMonster::OnLoaded, this, TimeTicks::Now()));
 }
 
 void CookieMonster::ReportLoaded() {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/457528 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("457528 CookieMonster::ReportLoaded"));
   if (delegate_.get())
     delegate_->OnLoaded();
 }
 
 void CookieMonster::OnLoaded(TimeTicks beginning_time,
                              const std::vector<CanonicalCookie*>& cookies) {
   StoreLoadedCookies(cookies);
   histogram_time_blocked_on_load_->AddTime(TimeTicks::Now() - beginning_time);
 
   // Invoke the task queue of cookie request.
   InvokeQueue();
 
   ReportLoaded();
 }
 
 void CookieMonster::OnKeyLoaded(const std::string& key,
                                 const std::vector<CanonicalCookie*>& cookies) {
   // This function does its own separate locking.
   StoreLoadedCookies(cookies);
 
   std::deque<scoped_refptr<CookieMonsterTask> > tasks_pending_for_key;
 
   // We need to do this repeatedly until no more tasks were added to the queue
   // during the period where we release the lock.
   while (true) {
+    // TODO(pkasting): Remove ScopedTracker below once crbug.com/456373 is
+    // fixed.
+    tracked_objects::ScopedTracker tracking_profile1(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION("456373 CookieMonster::OnKeyLoaded1"));
     {
       base::AutoLock autolock(lock_);
       std::map<std::string, std::deque<scoped_refptr<CookieMonsterTask> > >
         ::iterator it = tasks_pending_for_key_.find(key);
       if (it == tasks_pending_for_key_.end()) {
         keys_loaded_.insert(key);
         return;
       }
       if (it->second.empty()) {
         keys_loaded_.insert(key);
         tasks_pending_for_key_.erase(it);
         return;
       }
       it->second.swap(tasks_pending_for_key);
     }
 
+    // TODO(pkasting): Remove ScopedTracker below once crbug.com/456373 is
+    // fixed.
+    tracked_objects::ScopedTracker tracking_profile2(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION("456373 CookieMonster::OnKeyLoaded2"));
     while (!tasks_pending_for_key.empty()) {
       scoped_refptr<CookieMonsterTask> task = tasks_pending_for_key.front();
       task->Run();
       tasks_pending_for_key.pop_front();
     }
   }
 }
 
 void CookieMonster::StoreLoadedCookies(
     const std::vector<CanonicalCookie*>& cookies) {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/456373 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "456373 CookieMonster::StoreLoadedCookies"));
   // Initialize the store and sync in any saved persistent cookies.  We don't
   // care if it's expired, insert it so it can be garbage collected, removed,
   // and sync'd.
   base::AutoLock autolock(lock_);
 
   CookieItVector cookies_with_control_chars;
 
   for (std::vector<CanonicalCookie*>::const_iterator it = cookies.begin();
        it != cookies.end(); ++it) {
     int64 cookie_creation_time = (*it)->CreationDate().ToInternalValue();
@@ skipping 37 matching lines @@
   // none of our other constraints are violated.
   // In particular, the backing store might have given us duplicate cookies.
 
   // This method could be called multiple times due to priority loading, thus
   // cookies loaded in previous runs will be validated again, but this is OK
   // since they are expected to be much fewer than total DB.
   EnsureCookiesMapIsValid();
 }
 
 void CookieMonster::InvokeQueue() {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/457528 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("457528 CookieMonster::InvokeQueue"));
   while (true) {
     scoped_refptr<CookieMonsterTask> request_task;
     {
       base::AutoLock autolock(lock_);
       if (tasks_pending_.empty()) {
         loaded_ = true;
         creation_times_.clear();
         keys_loaded_.clear();
         break;
       }
@@ skipping 777 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, removed);
     }
   }
 }
 
 }  // namespace net