[Chromecast] Add proxy server support to chromecast

chromecast/net/connectivity_checker_impl.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_impl.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chromecast/base/metrics/cast_metrics_helper.h"
 #include "chromecast/chromecast_features.h"
 #include "chromecast/net/net_switches.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_status_code.h"
-#include "net/proxy/proxy_config.h"
-#include "net/proxy/proxy_config_service_fixed.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
+#include "net/url_request/url_request_context_getter.h"
 
 namespace chromecast {
 
 namespace {
 
 // How often connectivity checks are performed in seconds while not connected.
 const unsigned int kConnectivityPeriodSeconds = 1;
 
 #if BUILDFLAG(IS_CAST_AUDIO_ONLY)
 // How often connectivity checks are performed in seconds while connected.
@@ skipping 15 matching lines @@
 // Histogram "Cast.Network.Down.Duration.In.Seconds" shows 40% of network
 // downtime is less than 3 seconds.
 const char kNetworkChangedDelayInSeconds = 3;
 
 const char kMetricNameNetworkConnectivityCheckingErrorType[] =
     "Network.ConnectivityChecking.ErrorType";
 
 }  // namespace
 
 ConnectivityCheckerImpl::ConnectivityCheckerImpl(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    net::URLRequestContextGetter* url_request_context_getter)
     : ConnectivityChecker(),
       task_runner_(task_runner),
       connected_(false),
       connection_type_(net::NetworkChangeNotifier::CONNECTION_NONE),
       check_errors_(0),
       network_changed_pending_(false) {
   DCHECK(task_runner_.get());
+
   task_runner->PostTask(FROM_HERE,
-                        base::Bind(&ConnectivityCheckerImpl::Initialize, this));
+                        base::Bind(&ConnectivityCheckerImpl::Initialize, this,
+                                   url_request_context_getter));
 }
 
-void ConnectivityCheckerImpl::Initialize() {
+void ConnectivityCheckerImpl::Initialize(
+    net::URLRequestContextGetter* url_request_context_getter) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   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(
-      base::MakeUnique<net::ProxyConfigServiceFixed>(
-          net::ProxyConfig::CreateDirect()));
-  builder.DisableHttpCache();
-  url_request_context_ = builder.Build();
+  url_request_context_ = url_request_context_getter->GetURLRequestContext();
 
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&ConnectivityCheckerImpl::Check, this));
 }
 
 ConnectivityCheckerImpl::~ConnectivityCheckerImpl() {
   DCHECK(task_runner_.get());
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
   task_runner_->DeleteSoon(FROM_HERE, url_request_.release());
-  task_runner_->DeleteSoon(FROM_HERE, url_request_context_.release());
 }
 
 bool ConnectivityCheckerImpl::Connected() const {
   base::AutoLock auto_lock(connected_lock_);
   return connected_;
 }
 
 void ConnectivityCheckerImpl::SetConnected(bool connected) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (connected_ == connected)
     return;
   {
     base::AutoLock auto_lock(connected_lock_);
     connected_ = connected;
   }
   Notify(connected);
   LOG(INFO) << "Global connection is: " << (connected ? "Up" : "Down");
 }
 
 void ConnectivityCheckerImpl::Check() {
   task_runner_->PostTask(FROM_HERE,
       base::Bind(&ConnectivityCheckerImpl::CheckInternal, this));
 }
 
 void ConnectivityCheckerImpl::CheckInternal() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(url_request_context_.get());
+  DCHECK(url_request_context_);
 
   // 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
   // start another.
   if (url_request_.get())
     return;
@@ skipping 116 matching lines @@
 void ConnectivityCheckerImpl::Cancel() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (!url_request_.get())
     return;
   VLOG(2) << "Cancel connectivity check in progress";
   url_request_.reset(nullptr);  // URLRequest::Cancel() is called in destructor.
   timeout_.Cancel();
 }
 
 }  // namespace chromecast