Update net/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

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 1204 matching lines @@
   keep_expired_cookies_ = true;
 }
 
 // static
 void CookieMonster::EnableFileScheme() {
   default_enable_file_scheme_ = true;
 }
 
 void CookieMonster::FlushStore(const base::Closure& callback) {
   base::AutoLock autolock(lock_);
-  if (initialized_ && store_)
+  if (initialized_ && store_.get())
     store_->Flush(callback);
   else if (!callback.is_null())
     base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 bool CookieMonster::SetCookieWithOptions(const GURL& url,
                                          const std::string& cookie_line,
                                          const CookieOptions& options) {
   base::AutoLock autolock(lock_);
 
@@ skipping 98 matching lines @@
 }
 
 // This function must be called before the CookieMonster is used.
 void CookieMonster::SetPriorityAwareGarbageCollection(
     bool priority_aware_garbage_collection) {
   DCHECK(!initialized_);
   priority_aware_garbage_collection_ = priority_aware_garbage_collection;
 }
 
 void CookieMonster::SetForceKeepSessionState() {
-  if (store_) {
+  if (store_.get()) {
     store_->SetForceKeepSessionState();
   }
 }
 
 CookieMonster::~CookieMonster() {
   DeleteAll(false);
 }
 
 bool CookieMonster::SetCookieWithCreationTime(const GURL& url,
                                               const std::string& cookie_line,
                                               const base::Time& creation_time) {
-  DCHECK(!store_) << "This method is only to be used by unit-tests.";
+  DCHECK(!store_.get()) << "This method is only to be used by unit-tests.";
   base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url)) {
     return false;
   }
 
   InitIfNecessary();
   return SetCookieWithCreationTimeAndOptions(url, cookie_line, creation_time,
                                              CookieOptions());
 }
 
 void CookieMonster::InitStore() {
-  DCHECK(store_) << "Store must exist to initialize";
+  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::OnLoaded(TimeTicks beginning_time,
                              const std::vector<CanonicalCookie*>& cookies) {
   StoreLoadedCookies(cookies);
   histogram_time_blocked_on_load_->AddTime(TimeTicks::Now() - beginning_time);
@@ skipping 287 matching lines @@
     }
   }
   return skipped_httponly;
 }
 
 void CookieMonster::InternalInsertCookie(const std::string& key,
                                          CanonicalCookie* cc,
                                          bool sync_to_store) {
   lock_.AssertAcquired();
 
-  if ((cc->IsPersistent() || persist_session_cookies_) &&
-      store_ && sync_to_store)
+  if ((cc->IsPersistent() || persist_session_cookies_) && store_.get() &&
+      sync_to_store)
     store_->AddCookie(*cc);
   cookies_.insert(CookieMap::value_type(key, cc));
   if (delegate_.get()) {
     delegate_->OnCookieChanged(
         *cc, false, CookieMonster::Delegate::CHANGE_COOKIE_EXPLICIT);
   }
 }
 
 bool CookieMonster::SetCookieWithCreationTimeAndOptions(
     const GURL& url,
@@ skipping 67 matching lines @@
   // updates we do during pageload, which in turn reduces the chance our storage
   // backend will hit its batch thresholds and be forced to update.
   if ((current - cc->LastAccessDate()) < last_access_threshold_)
     return;
 
   // See InitializeHistograms() for details.
   histogram_between_access_interval_minutes_->Add(
       (current - cc->LastAccessDate()).InMinutes());
 
   cc->SetLastAccessDate(current);
-  if ((cc->IsPersistent() || persist_session_cookies_) && store_)
+  if ((cc->IsPersistent() || persist_session_cookies_) && store_.get())
     store_->UpdateCookieAccessTime(*cc);
 }
 
 void CookieMonster::InternalDeleteCookie(CookieMap::iterator it,
                                          bool sync_to_store,
                                          DeletionCause deletion_cause) {
   lock_.AssertAcquired();
 
   // Ideally, this would be asserted up where we define ChangeCauseMapping,
   // but DeletionCause's visibility (or lack thereof) forces us to make
   // this check here.
   COMPILE_ASSERT(arraysize(ChangeCauseMapping) == DELETE_COOKIE_LAST_ENTRY + 1,
                  ChangeCauseMapping_size_not_eq_DeletionCause_enum_size);
 
   // See InitializeHistograms() for details.
   if (deletion_cause != DELETE_COOKIE_DONT_RECORD)
     histogram_cookie_deletion_cause_->Add(deletion_cause);
 
   CanonicalCookie* cc = it->second;
   VLOG(kVlogSetCookies) << "InternalDeleteCookie() cc: " << cc->DebugString();
 
-  if ((cc->IsPersistent() || persist_session_cookies_)
-      && store_ && sync_to_store)
+  if ((cc->IsPersistent() || persist_session_cookies_) && store_.get() &&
+      sync_to_store)
     store_->DeleteCookie(*cc);
   if (delegate_.get()) {
     ChangeCausePair mapping = ChangeCauseMapping[deletion_cause];
 
     if (mapping.notify)
       delegate_->OnCookieChanged(*cc, true, mapping.cause);
   }
   cookies_.erase(it);
   delete cc;
 }
@@ skipping 350 matching lines @@
 
 // The system resolution is not high enough, so we can have multiple
 // set cookies that result in the same system time.  When this happens, we
 // increment by one Time unit.  Let's hope computers don't get too fast.
 Time CookieMonster::CurrentTime() {
   return std::max(Time::Now(),
       Time::FromInternalValue(last_time_seen_.ToInternalValue() + 1));
 }
 
 }  // namespace net