Chromecast: MessageLoopProxy cleanup --> SingleThreadTaskRunner.

chromecast/net/connectivity_checker.cc

 // Copyright 2015 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 "chromecast/net/connectivity_checker.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "chromecast/net/net_switches.h"
@@ skipping 17 matching lines @@
 // to offline.
 const unsigned int kNumErrorsToNotifyOffline = 3;
 
 // Default url for connectivity checking.
 const char kDefaultConnectivityCheckUrl[] =
     "https://clients3.google.com/generate_204";
 
 }  // namespace
 
 ConnectivityChecker::ConnectivityChecker(
-    const scoped_refptr<base::MessageLoopProxy>& loop_proxy)
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : connectivity_observer_list_(
           new ObserverListThreadSafe<ConnectivityObserver>()),
-      loop_proxy_(loop_proxy),
+      task_runner_(task_runner),
       connected_(false),
       check_errors_(0) {
-  DCHECK(loop_proxy_.get());
-  loop_proxy->PostTask(FROM_HERE,
-                       base::Bind(&ConnectivityChecker::Initialize, this));
+  DCHECK(task_runner_.get());
+  task_runner->PostTask(FROM_HERE,
+                        base::Bind(&ConnectivityChecker::Initialize, this));
 }
 
 void ConnectivityChecker::Initialize() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   base::CommandLine::StringType check_url_str =
       command_line->GetSwitchValueNative(switches::kConnectivityCheckUrl);
   connectivity_check_url_.reset(new GURL(
       check_url_str.empty() ? kDefaultConnectivityCheckUrl : check_url_str));
 
   net::URLRequestContextBuilder builder;
   builder.set_proxy_config_service(
       new net::ProxyConfigServiceFixed(net::ProxyConfig::CreateDirect()));
   builder.DisableHttpCache();
   url_request_context_.reset(builder.Build());
 
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
-  loop_proxy_->PostTask(FROM_HERE,
-                        base::Bind(&ConnectivityChecker::Check, this));
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&ConnectivityChecker::Check, this));
 }
 
 ConnectivityChecker::~ConnectivityChecker() {
-  DCHECK(loop_proxy_.get());
+  DCHECK(task_runner_.get());
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
-  loop_proxy_->DeleteSoon(FROM_HERE, url_request_context_.release());
-  loop_proxy_->DeleteSoon(FROM_HERE, url_request_.release());
+  task_runner_->DeleteSoon(FROM_HERE, url_request_context_.release());
+  task_runner_->DeleteSoon(FROM_HERE, url_request_.release());
 }
 
 void ConnectivityChecker::AddConnectivityObserver(
     ConnectivityObserver* observer) {
   connectivity_observer_list_->AddObserver(observer);
 }
 
 void ConnectivityChecker::RemoveConnectivityObserver(
     ConnectivityObserver* observer) {
   connectivity_observer_list_->RemoveObserver(observer);
 }
 
 bool ConnectivityChecker::Connected() const {
   return connected_;
 }
 
 void ConnectivityChecker::SetConnectivity(bool connected) {
   if (connected_ == connected)
     return;
 
   connected_ = connected;
   connectivity_observer_list_->Notify(
       FROM_HERE, &ConnectivityObserver::OnConnectivityChanged, connected);
   LOG(INFO) << "Global connection is: " << (connected ? "Up" : "Down");
 }
 
 void ConnectivityChecker::Check() {
-  if (!loop_proxy_->BelongsToCurrentThread()) {
-    loop_proxy_->PostTask(FROM_HERE,
-                          base::Bind(&ConnectivityChecker::Check, this));
+  if (!task_runner_->BelongsToCurrentThread()) {
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&ConnectivityChecker::Check, this));
     return;
   }
   DCHECK(url_request_context_.get());
 
   // Don't check connectivity if network is offline, because Internet could be
   // accessible via netifs ignored.
   if (net::NetworkChangeNotifier::IsOffline())
     return;
 
   // If url_request_ is non-null, there is already a check going on. Don't
@@ skipping 53 matching lines @@
 }
 
 void ConnectivityChecker::OnUrlRequestError() {
   ++check_errors_;
   if (check_errors_ > kNumErrorsToNotifyOffline) {
     check_errors_ = kNumErrorsToNotifyOffline;
     SetConnectivity(false);
   }
   url_request_.reset(NULL);
   // Check again.
-  loop_proxy_->PostDelayedTask(
+  task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&ConnectivityChecker::Check, this),
       base::TimeDelta::FromSeconds(kConnectivityPeriodSeconds));
 }
 
 void ConnectivityChecker::OnReadCompleted(net::URLRequest* request,
                                           int bytes_read) {
   NOTREACHED();
 }
 
 void ConnectivityChecker::Cancel() {
   if (url_request_.get()) {
     VLOG(2) << "Cancel connectivity check in progress";
     url_request_.reset(NULL);  // URLRequest::Cancel() is called in destructor.
   }
 }
 
 }  // namespace chromecast