More fixes for scoped_refptr operator T* removal.

net/proxy/proxy_config_service_linux.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.
 
 #include "net/proxy/proxy_config_service_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #if defined(USE_GCONF)
 #include <gconf/gconf-client.h>
@@ skipping 1560 matching lines @@
     const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner) {
   // We should be running on the default glib main loop thread right
   // now. gconf can only be accessed from this thread.
   DCHECK(glib_task_runner->BelongsToCurrentThread());
   glib_task_runner_ = glib_task_runner;
   io_task_runner_ = io_task_runner;
 
   // If we are passed a NULL |io_task_runner| or |file_task_runner|, then we
   // don't set up proxy setting change notifications. This should not be the
   // usual case but is intended to/ simplify test setups.
-  if (!io_task_runner_.get() || !file_task_runner)
+  if (!io_task_runner_.get() || !file_task_runner.get())
     VLOG(1) << "Monitoring of proxy setting changes is disabled";
 
   // Fetch and cache the current proxy config. The config is left in
   // cached_config_, where GetLatestProxyConfig() running on the IO thread
   // will expect to find it. This is safe to do because we return
   // before this ProxyConfigServiceLinux is passed on to
   // the ProxyService.
 
   // Note: It would be nice to prioritize environment variables
   // and only fall back to gconf if env vars were unset. But
@@ skipping 21 matching lines @@
     reference_config_ = cached_config_;
     reference_config_.set_id(1);  // Mark it as valid.
 
     // We only set up notifications if we have IO and file loops available.
     // We do this after getting the initial configuration so that we don't have
     // to worry about cancelling it if the initial fetch above fails. Note that
     // setting up notifications has the side effect of simulating a change, so
     // that we won't lose any updates that may have happened after the initial
     // fetch and before setting up notifications. We'll detect the common case
     // of no changes in OnCheckProxyConfigSettings() (or sooner) and ignore it.
-    if (io_task_runner && file_task_runner) {
+    if (io_task_runner.get() && file_task_runner.get()) {
       scoped_refptr<base::SingleThreadTaskRunner> required_loop =
           setting_getter_->GetNotificationTaskRunner();
       if (!required_loop.get() || required_loop->BelongsToCurrentThread()) {
         // In this case we are already on an acceptable thread.
         SetUpNotifications();
       } else {
         // Post a task to set up notifications. We don't wait for success.
         required_loop->PostTask(FROM_HERE, base::Bind(
             &ProxyConfigServiceLinux::Delegate::SetUpNotifications, this));
       }
@@ skipping 139 matching lines @@
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net