Revert of ios: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

ios/crnet/crnet_environment.mm

 // 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 "ios/crnet/crnet_environment.h"
 
 #import <Foundation/Foundation.h>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
@@ skipping 37 matching lines @@
 
 namespace {
 
 base::AtExitManager* g_at_exit_ = nullptr;
 
 // Request context getter for CrNet.
 class CrNetURLRequestContextGetter : public net::URLRequestContextGetter {
  public:
   CrNetURLRequestContextGetter(
       net::URLRequestContext* context,
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
-      : context_(context), task_runner_(task_runner) {}
+      const scoped_refptr<base::MessageLoopProxy>& loop)
+      : context_(context), loop_(loop) {}
 
   net::URLRequestContext* GetURLRequestContext() override { return context_; }
 
   scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()
       const override {
-    return task_runner_;
+    return loop_;
   }
  private:
   // Must be called on the IO thread.
   ~CrNetURLRequestContextGetter() override {}
 
   net::URLRequestContext* context_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_refptr<base::MessageLoopProxy> loop_;
   DISALLOW_COPY_AND_ASSIGN(CrNetURLRequestContextGetter);
 };
 
 }  // namespace
 
 // net::HTTPProtocolHandlerDelegate for CrNet.
 class CrNetHttpProtocolHandlerDelegate
     : public net::HTTPProtocolHandlerDelegate {
  public:
   CrNetHttpProtocolHandlerDelegate(net::URLRequestContextGetter* getter,
@@ skipping 170 matching lines @@
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   file_user_blocking_thread_.reset(
       new base::Thread("Chrome File User Blocking Thread"));
   file_user_blocking_thread_->StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
 
   // The network change notifier must be initialized so that registered
   // delegates will receive callbacks.
   network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
   proxy_config_service_.reset(net::ProxyService::CreateSystemProxyConfigService(
-      network_io_thread_->task_runner(), nullptr));
+      network_io_thread_->message_loop_proxy(), nullptr));
 
   PostToNetworkThread(FROM_HERE,
       base::Bind(&CrNetEnvironment::InitializeOnNetworkThread,
                  base::Unretained(this)));
 
   net::SetURLRequestContextForNSSHttpIO(main_context_.get());
   main_context_getter_ = new CrNetURLRequestContextGetter(
-      main_context_.get(), network_io_thread_->task_runner());
+      main_context_.get(), network_io_thread_->message_loop_proxy());
   SetRequestFilterBlock(nil);
   net_log_started_ = false;
 }
 
 void CrNetEnvironment::InstallIntoSessionConfiguration(
     NSURLSessionConfiguration* config) {
   config.protocolClasses = @[ [CRNHTTPProtocolHandler class] ];
 }
 
 CrNetEnvironment::~CrNetEnvironment() {
@@ skipping 21 matching lines @@
   }
 }
 
 void CrNetEnvironment::InitializeOnNetworkThread() {
   DCHECK(base::MessageLoop::current() == network_io_thread_->message_loop());
 
   // Register network clients.
   net::RequestTracker::AddGlobalNetworkClientFactory(
       [[[WebPNetworkClientFactory alloc]
           initWithTaskRunner:file_user_blocking_thread_
-                                 ->task_runner()] autorelease]);
+                                 ->message_loop_proxy()] autorelease]);
 
 #if 0
   // TODO(huey): Re-enable this once SDCH supports SSL and dictionaries from
   // previous sessions can be used on the first request after a fresh launch.
   sdch_manager_.reset(new net::SdchManager());
   sdch_manager_->set_sdch_fetcher(
       new SdchDictionaryFetcher(main_context_getter_));
 #else
   // Otherwise, explicitly disable SDCH to avoid a crash.
   net::SdchManager::EnableSdchSupport(false);
@@ skipping 42 matching lines @@
           proxy_config_service_.get(), 0, nullptr));
 
   // Cache
   NSArray* dirs = NSSearchPathForDirectoriesInDomains(NSCachesDirectory,
                                                       NSUserDomainMask,
                                                       YES);
   base::FilePath cache_path =
       base::mac::NSStringToFilePath([dirs objectAtIndex:0]);
   cache_path = cache_path.Append(FILE_PATH_LITERAL("crnet"));
   net::HttpCache::DefaultBackend* main_backend =
-      new net::HttpCache::DefaultBackend(net::DISK_CACHE,
-                                         net::CACHE_BACKEND_DEFAULT, cache_path,
-                                         0,  // Default cache size.
-                                         network_cache_thread_->task_runner());
+      new net::HttpCache::DefaultBackend(
+          net::DISK_CACHE,
+          net::CACHE_BACKEND_DEFAULT,
+          cache_path,
+          0,  // Default cache size.
+          network_cache_thread_->message_loop_proxy());
 
   net::HttpNetworkSession::Params params;
   params.host_resolver = main_context_->host_resolver();
   params.cert_verifier = main_context_->cert_verifier();
   params.channel_id_service = main_context_->channel_id_service();
   params.transport_security_state = main_context_->transport_security_state();
   params.proxy_service = main_context_->proxy_service();
   params.ssl_session_cache_shard = "";
   params.ssl_config_service = main_context_->ssl_config_service();
   params.http_auth_handler_factory = main_context_->http_auth_handler_factory();
@@ skipping 22 matching lines @@
 
   // Cookies
   scoped_refptr<net::CookieStore> cookie_store =
       net::CookieStoreIOS::CreateCookieStoreFromNSHTTPCookieStorage();
   main_context_->set_cookie_store(cookie_store.get());
 
   net::URLRequestJobFactoryImpl* job_factory =
       new net::URLRequestJobFactoryImpl;
   job_factory->SetProtocolHandler("data", new net::DataProtocolHandler);
   job_factory->SetProtocolHandler(
-      "file", new net::FileProtocolHandler(file_thread_->task_runner()));
+      "file", new net::FileProtocolHandler(file_thread_->message_loop_proxy()));
   main_context_->set_job_factory(job_factory);
 }
 
 std::string CrNetEnvironment::user_agent() {
   const net::HttpUserAgentSettings* user_agent_settings =
       main_context_->http_user_agent_settings();
   if (!user_agent_settings) {
     return nullptr;
   }
 
@@ skipping 20 matching lines @@
       if (backend)
         backend->DoomAllEntries(client_callback);
   });
   int rc = cache->GetBackend(&backend, doom_callback);
   if (rc != net::ERR_IO_PENDING) {
     // GetBackend doesn't call the callback if it completes synchronously, so
     // call it directly here.
     doom_callback.Run(rc);
   }
 }