Remove implicit conversions from scoped_refptr to T* in components/search_provider_logos/

components/search_provider_logos/logo_tracker.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 "components/search_provider_logos/logo_tracker.h"
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "base/task_runner_util.h"
@@ skipping 89 matching lines @@
   append_fingerprint_func_ = append_fingerprint_func;
 }
 
 void LogoTracker::GetLogo(LogoObserver* observer) {
   DCHECK(!logo_url_.is_empty());
   logo_observers_.AddObserver(observer);
 
   if (is_idle_) {
     is_idle_ = false;
     base::PostTaskAndReplyWithResult(
-        file_task_runner_,
+        file_task_runner_.get(),
         FROM_HERE,
         base::Bind(&GetLogoFromCacheOnFileThread,
                    logo_cache_,
                    logo_url_,
                    clock_->Now()),
         base::Bind(&LogoTracker::OnCachedLogoRead,
                    weak_ptr_factory_.GetWeakPtr()));
   } else if (is_cached_logo_valid_) {
     observer->OnLogoAvailable(cached_logo_.get(), true);
   }
@@ skipping 80 matching lines @@
   GURL url;
   if (cached_logo_ && !cached_logo_->metadata.fingerprint.empty() &&
       cached_logo_->metadata.expiration_time >= clock_->Now()) {
     url = append_fingerprint_func_.Run(logo_url_,
                                        cached_logo_->metadata.fingerprint);
   } else {
     url = logo_url_;
   }
 
   fetcher_.reset(net::URLFetcher::Create(url, net::URLFetcher::GET, this));
-  fetcher_->SetRequestContext(request_context_getter_);
+  fetcher_->SetRequestContext(request_context_getter_.get());
   fetcher_->Start();
 }
 
 void LogoTracker::OnFreshLogoParsed(scoped_ptr<EncodedLogo> logo) {
   DCHECK(!is_idle_);
 
   if (logo)
     logo->metadata.source_url = logo_url_.spec();
 
-  if (!logo || !logo->encoded_image) {
+  if (!logo || !logo->encoded_image.get()) {
     OnFreshLogoAvailable(logo.Pass(), SkBitmap());
   } else {
     // Store the value of logo->encoded_image for use below. This ensures that
     // logo->encoded_image is evaulated before base::Passed(&logo), which sets
     // logo to NULL.
     scoped_refptr<base::RefCountedString> encoded_image = logo->encoded_image;
     logo_delegate_->DecodeUntrustedImage(
         encoded_image,
         base::Bind(&LogoTracker::OnFreshLogoAvailable,
                    weak_ptr_factory_.GetWeakPtr(),
                    base::Passed(&logo)));
   }
 }
 
 void LogoTracker::OnFreshLogoAvailable(scoped_ptr<EncodedLogo> encoded_logo,
                                        const SkBitmap& image) {
   DCHECK(!is_idle_);
 
-  if (encoded_logo && !encoded_logo->encoded_image && cached_logo_ &&
+  if (encoded_logo && !encoded_logo->encoded_image.get() && cached_logo_ &&
       !encoded_logo->metadata.fingerprint.empty() &&
       encoded_logo->metadata.fingerprint ==
           cached_logo_->metadata.fingerprint) {
     // The cached logo was revalidated, i.e. its fingerprint was verified.
     SetCachedMetadata(encoded_logo->metadata);
   } else if (encoded_logo && image.isNull()) {
     // Image decoding failed. Do nothing.
   } else {
     scoped_ptr<Logo> logo;
     // Check if the server returned a valid, non-empty response.
@@ skipping 24 matching lines @@
   if (!source->GetStatus().is_success() || (source->GetResponseCode() != 200)) {
     ReturnToIdle();
     return;
   }
 
   scoped_ptr<std::string> response(new std::string());
   source->GetResponseAsString(response.get());
   base::Time response_time = clock_->Now();
 
   base::PostTaskAndReplyWithResult(
-      background_task_runner_,
+      background_task_runner_.get(),
       FROM_HERE,
-      base::Bind(parse_logo_response_func_,
-                 base::Passed(&response),
-                 response_time),
+      base::Bind(
+          parse_logo_response_func_, base::Passed(&response), response_time),
       base::Bind(&LogoTracker::OnFreshLogoParsed,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void LogoTracker::OnURLFetchDownloadProgress(const net::URLFetcher* source,
                                              int64 current,
                                              int64 total) {
   if (total > kMaxDownloadBytes || current > kMaxDownloadBytes) {
     LOG(WARNING) << "Search provider logo exceeded download size limit";
     ReturnToIdle();
   }
 }
 
 }  // namespace search_provider_logos