Remove implicit conversions from scoped_refptr to T* in chrome/browser/prerender/

chrome/browser/prerender/prerender_cookie_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 "chrome/browser/prerender/prerender_cookie_store.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace prerender {
 
 PrerenderCookieStore::PrerenderCookieStore(
     scoped_refptr<net::CookieMonster> default_cookie_monster,
     const base::Closure& cookie_conflict_cb)
     : in_forwarding_mode_(false),
       default_cookie_monster_(default_cookie_monster),
       changes_cookie_monster_(new net::CookieMonster(NULL, NULL)),
       cookie_conflict_cb_(cookie_conflict_cb),
       cookie_conflict_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(default_cookie_monster_ != NULL);
+  DCHECK(default_cookie_monster_.get() != NULL);
   DCHECK(default_cookie_monster_->loaded());
 }
 
 PrerenderCookieStore::~PrerenderCookieStore() {
 }
 
 void PrerenderCookieStore::SetCookieWithOptionsAsync(
     const GURL& url,
     const std::string& cookie_line,
     const net::CookieOptions& options,
@@ skipping 77 matching lines @@
 
 net::CookieStore* PrerenderCookieStore::GetCookieStoreForCookieOpAndLog(
     const CookieOperation& op) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   std::string key = default_cookie_monster_->GetKey(op.url.host());
   bool is_read_only = (op.op == COOKIE_OP_GET_COOKIES_WITH_OPTIONS_ASYNC ||
                        op.op == COOKIE_OP_GET_ALL_COOKIES_FOR_URL_ASYNC);
 
   if (in_forwarding_mode_)
-    return default_cookie_monster_;
+    return default_cookie_monster_.get();
 
-  DCHECK(changes_cookie_monster_ != NULL);
+  DCHECK(changes_cookie_monster_.get() != NULL);
 
   cookie_ops_.push_back(op);
 
   bool key_copied = ContainsKey(copied_keys_, key);
 
   if (key_copied)
-    return changes_cookie_monster_;
+    return changes_cookie_monster_.get();
 
   if (is_read_only) {
     // Insert this key into the set of read keys, if it doesn't exist yet.
     if (!ContainsKey(read_keys_, key))
       read_keys_.insert(key);
-    return default_cookie_monster_;
+    return default_cookie_monster_.get();
   }
 
   // If this method hasn't returned yet, the key has not been copied yet,
   // and we must copy it due to the requested write operation.
 
-  bool copy_success = default_cookie_monster_->
-      CopyCookiesForKeyToOtherCookieMonster(key, changes_cookie_monster_);
+  bool copy_success =
+      default_cookie_monster_->CopyCookiesForKeyToOtherCookieMonster(
+          key, changes_cookie_monster_.get());
 
   // The copy must succeed.
   DCHECK(copy_success);
 
   copied_keys_.insert(key);
 
-  return changes_cookie_monster_;
+  return changes_cookie_monster_.get();
 }
 
 void PrerenderCookieStore::ApplyChanges(std::vector<GURL>* cookie_change_urls) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (in_forwarding_mode_)
     return;
 
   // Apply all changes to the underlying cookie store.
   for (std::vector<CookieOperation>::const_iterator it = cookie_ops_.begin();
@@ skipping 29 matching lines @@
   changes_cookie_monster_ = NULL;
 }
 
 void PrerenderCookieStore::OnCookieChangedForURL(
     net::CookieMonster* cookie_monster,
     const GURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // If the cookie was changed in a different cookie monster than the one
   // being decorated, there is nothing to do).
-  if (cookie_monster != default_cookie_monster_)
+  if (cookie_monster != default_cookie_monster_.get())
     return;
 
   if (in_forwarding_mode_)
     return;
 
   // If we have encountered a conflict before, it has already been recorded
   // and the cb has been issued, so nothing to do.
   if (cookie_conflict_)
     return;
 
@@ skipping 20 matching lines @@
   }
 }
 
 PrerenderCookieStore::CookieOperation::CookieOperation() {
 }
 
 PrerenderCookieStore::CookieOperation::~CookieOperation() {
 }
 
 }  // namespace prerender