Move common functionality of IOSChromeIOThread to ios/components.

ios/components/io_thread/io_thread.h

-// Copyright 2015 The Chromium Authors. All rights reserved.
+// Copyright 2017 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.
 
-#ifndef IOS_CHROME_BROWSER_IOS_CHROME_IO_THREAD_H_
-#define IOS_CHROME_BROWSER_IOS_CHROME_IO_THREAD_H_
+#ifndef IOS_COMPONENTS_IO_THREAD_IO_THREAD_H_
+#define IOS_COMPONENTS_IO_THREAD_IO_THREAD_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "components/prefs/pref_member.h"
 #include "components/ssl_config/ssl_config_service_manager.h"
 #include "ios/web/public/web_thread_delegate.h"
 #include "net/base/network_change_notifier.h"
 #include "net/http/http_network_session.h"
 
 class PrefProxyConfigTracker;
 class PrefService;
-class SystemURLRequestContextGetter;
 
 namespace net {
 class CTPolicyEnforcer;
 class CertVerifier;
 class ChannelIDService;
 class CookieStore;
 class CTVerifier;
 class HostResolver;
 class HttpAuthHandlerFactory;
 class HttpAuthPreferences;
 class HttpServerProperties;
 class HttpTransactionFactory;
 class HttpUserAgentSettings;
 class NetworkDelegate;
 class NetworkQualityEstimator;
 class ProxyConfigService;
 class ProxyService;
 class SSLConfigService;
 class TransportSecurityState;
 class URLRequestContext;
 class URLRequestContextGetter;
 class URLRequestJobFactory;
 }  // namespace net
 
 namespace net_log {
 class ChromeNetLog;
 }  // namespace net_log
 
+namespace io_thread {
+
 class SystemURLRequestContextGetter;
 
 // Contains state associated with, initialized and cleaned up on, and
 // primarily used on, the IO thread.
 //
 // If you are looking to interact with the IO thread (e.g. post tasks
 // to it or check if it is the current thread), see web::WebThread.
-class IOSChromeIOThread : public web::WebThreadDelegate {
+class IOThread : public web::WebThreadDelegate {

[Eugene But (OOO till 7-30), 2017/05/25 22:05:22]

Should this be IOSIOThread? 

[michaeldo, 2017/05/26 07:24:43]

I think IOSIOThread makes sense. Updated.

  public:
   struct Globals {
     template <typename T>
     class Optional {
      public:
       Optional() : set_(false) {}
 
       void set(T value) {
         set_ = true;
         value_ = value;
@@ skipping 43 matching lines @@
         system_http_transaction_factory;
     std::unique_ptr<net::URLRequestJobFactory> system_url_request_job_factory;
     std::unique_ptr<net::URLRequestContext> system_request_context;
     SystemRequestContextLeakChecker system_request_context_leak_checker;
     std::unique_ptr<net::CookieStore> system_cookie_store;
     std::unique_ptr<net::HttpUserAgentSettings> http_user_agent_settings;
     std::unique_ptr<net::NetworkQualityEstimator> network_quality_estimator;
     std::unique_ptr<net::CTPolicyEnforcer> ct_policy_enforcer;
   };
 
-  // |net_log| must either outlive the IOSChromeIOThread or be NULL.
-  IOSChromeIOThread(PrefService* local_state, net_log::ChromeNetLog* net_log);
-
-  ~IOSChromeIOThread() override;
+  // |net_log| must either outlive the IOThread or be NULL.
+  IOThread(PrefService* local_state, net_log::ChromeNetLog* net_log);
+  ~IOThread() override;
 
   // Can only be called on the IO thread.
   Globals* globals();
 
-  // Allows overriding Globals in tests where IOSChromeIOThread::Init() and
-  // IOSChromeIOThread::CleanUp() are not called.  This allows for injecting
-  // mocks into IOSChromeIOThread global objects.
+  // Allows overriding Globals in tests where IOThread::Init() and
+  // IOThread::CleanUp() are not called.  This allows for injecting mocks into
+  // IOThread global objects.
   void SetGlobalsForTesting(Globals* globals);
 
   net_log::ChromeNetLog* net_log();
 
   // Handles changing to On The Record mode, discarding confidential data.
   void ChangedToOnTheRecord();
 
   // Returns a getter for the URLRequestContext.  Only called on the UI thread.
   net::URLRequestContextGetter* system_url_request_context_getter();
 
   // Clears the host cache.  Intended to be used to prevent exposing recently
   // visited sites on about:net-internals/#dns and about:dns pages.  Must be
   // called on the IO thread.
   void ClearHostCache();
 
   const net::HttpNetworkSession::Params& NetworkSessionParams() const;
 
   base::TimeTicks creation_time() const;
 
+ protected:
+  std::string GetChannelString();

[Eugene But (OOO till 7-30), 2017/05/25 22:05:21]

Should this be virtual and const? Otherwise subclass' implementation will never
be called. 

[michaeldo, 2017/05/26 07:24:43]

Done.

+
+  virtual std::unique_ptr<net::NetworkDelegate> GetSystemNetworkDelegate() = 0;
+
  private:
   // Provide SystemURLRequestContextGetter with access to
   // InitSystemRequestContext().
   friend class SystemURLRequestContextGetter;
 
   // WebThreadDelegate implementation, runs on the IO thread.
   // This handles initialization and destruction of state that must
   // live on the IO thread.
   void Init() override;
   void CleanUp() override;
@@ skipping 18 matching lines @@
   static net::URLRequestContext* ConstructSystemRequestContext(
       Globals* globals,
       const net::HttpNetworkSession::Params& params,
       net::NetLog* net_log);
 
   // The NetLog is owned by the application context, to allow logging from other
   // threads during shutdown, but is used most frequently on the IO thread.
   net_log::ChromeNetLog* net_log_;
 
   // These member variables are basically global, but their lifetimes are tied
-  // to the IOSChromeIOThread.  IOSChromeIOThread owns them all, despite not
-  // using scoped_ptr. This is because the destructor of IOSChromeIOThread runs
-  // on the wrong thread.  All member variables should be deleted in CleanUp().
+  // to the IOThread.  IOThread owns them all, despite not using
+  // scoped_ptr. This is because the destructor of IOThread runs on the
+  // wrong thread.  All member variables should be deleted in CleanUp().
 
   // These member variables are initialized in Init() and do not change for the
   // lifetime of the IO thread.
 
   Globals* globals_;
 
   net::HttpNetworkSession::Params params_;
 
   // Observer that logs network changes to the ChromeNetLog.
   class LoggingNetworkChangeObserver;
   std::unique_ptr<LoggingNetworkChangeObserver> network_change_observer_;
 
   // This is an instance of the default SSLConfigServiceManager for the current
   // platform and it gets SSL preferences from local_state object.
   std::unique_ptr<ssl_config::SSLConfigServiceManager>
       ssl_config_service_manager_;
 
   // These member variables are initialized by a task posted to the IO thread,
-  // which gets posted by calling certain member functions of IOSChromeIOThread.
+  // which gets posted by calling certain member functions of IOThread.
   std::unique_ptr<net::ProxyConfigService> system_proxy_config_service_;
 
   std::unique_ptr<PrefProxyConfigTracker> pref_proxy_config_tracker_;
 
   scoped_refptr<SystemURLRequestContextGetter>
       system_url_request_context_getter_;
 
   const base::TimeTicks creation_time_;
 
-  base::WeakPtrFactory<IOSChromeIOThread> weak_factory_;
+  base::WeakPtrFactory<IOThread> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(IOSChromeIOThread);
+  DISALLOW_COPY_AND_ASSIGN(IOThread);
 };
 
-#endif  // IOS_CHROME_BROWSER_IOS_CHROME_IO_THREAD_H_
+}  // namespace io_thread
+
+#endif  // IOS_COMPONENTS_IO_THREAD_IO_THREAD_H_