Lazily initialize MessageLoop for faster thread startup

net/android/network_change_notifier_android.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.
 
 ////////////////////////////////////////////////////////////////////////////////
 // Threading considerations:
 //
 // This class is designed to meet various threading guarantees starting from the
 // ones imposed by NetworkChangeNotifier:
 // - The notifier can be constructed on any thread.
@@ skipping 41 matching lines @@
 // delegate then forwards these notifications to the threads of each observer
 // (network change notifier). The network change notifier than processes the
 // state change, and notifies each of its observers on their threads.
 //
 // This can also be seen as:
 // Android platform -> NetworkChangeNotifier (Java) ->
 // NetworkChangeNotifierDelegateAndroid -> NetworkChangeNotifierAndroid.
 
 #include "net/android/network_change_notifier_android.h"
 
+#include "base/memory/weak_ptr.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "net/base/address_tracker_linux.h"
 #include "net/dns/dns_config_service_posix.h"
 
 namespace net {
 
 // Thread on which we can run DnsConfigService, which requires a TYPE_IO
 // message loop to monitor /system/etc/hosts.
 class NetworkChangeNotifierAndroid::DnsConfigServiceThread
     : public base::Thread,
       public NetworkChangeNotifier::NetworkChangeObserver {
  public:
   DnsConfigServiceThread(const DnsConfig* dns_config_for_testing)
       : base::Thread("DnsConfigService"),
+        calling_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         dns_config_for_testing_(dns_config_for_testing),
         creation_time_(base::Time::Now()),
         address_tracker_(base::Bind(base::DoNothing),
                          base::Bind(base::DoNothing),
                          // We're only interested in tunnel interface changes.
-                         base::Bind(NotifyNetworkChangeNotifierObservers)) {}
+                         base::Bind(NotifyNetworkChangeNotifierObservers)),
+        weak_ptr_factory_(this) {
+    weak_ptr_ = weak_ptr_factory_.GetWeakPtr();
+  }
 
   ~DnsConfigServiceThread() override {
     NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
     Stop();
   }
 
   void InitAfterStart() {
     DCHECK(IsRunning());
     NetworkChangeNotifier::AddNetworkChangeObserver(this);
   }
 
   void Init() override {
     address_tracker_.Init();
     dns_config_service_.reset(new internal::DnsConfigServicePosix());
     if (dns_config_for_testing_)
       dns_config_service_->SetDnsConfigForTesting(dns_config_for_testing_);
     dns_config_service_->WatchConfig(
         base::Bind(&DnsConfigServiceThread::DnsConfigChangeCallback,
                    base::Unretained(this)));
+    calling_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&DnsConfigServiceThread::InitAfterStart, weak_ptr_));

[pauljensen, 2015/05/01 11:54:44]

This is not good.  This will allow changes to escape the DnsConfigService.
The tiny and fast code in InitAfterStart() must block creation of
NetworkChangeNotifierAndroid.
I think we could just get rid of the DCHECK(IsRunning()) in InitAfterStart(),
which is probably causing the crash you mention.  The code in OnNetworkChanged
may need to change however.  Is task_runner() guaranteed to return non-null
after Thread()?

[kinuko, 2015/05/01 13:58:05]

Ok thanks, I suspected it might be the case. I can modify this part block.
No, the reason it was crashing was
NetworkChangeNotifier::AddNetworkChangeObserver(this) in InitAfterStart() gets
called and OnNetworkChanged() is called by the notifier before we initialize
dns_config_service_ in Init(), so the PostTask on line 132 tries to run
DnsConfigServicePosix::OnNetworkChanged on nullptr.
Yes.

   }
 
   void CleanUp() override { dns_config_service_.reset(); }
 
   static void NotifyNetworkChangeNotifierObservers() {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChange();
     NetworkChangeNotifier::NotifyObserversOfConnectionTypeChange();
   }
 
  private:
   void DnsConfigChangeCallback(const DnsConfig& config) {
     DCHECK(task_runner()->BelongsToCurrentThread());
     if (dns_config_service_->SeenChangeSince(creation_time_)) {
       NetworkChangeNotifier::SetDnsConfig(config);
     } else {
       NetworkChangeNotifier::SetInitialDnsConfig(config);
     }
   }
 
   // NetworkChangeNotifier::NetworkChangeObserver implementation:
   void OnNetworkChanged(NetworkChangeNotifier::ConnectionType type) override {
     task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&internal::DnsConfigServicePosix::OnNetworkChanged,
                    base::Unretained(dns_config_service_.get()), type));
   }
 
+  scoped_refptr<base::SingleThreadTaskRunner> calling_task_runner_;
   const DnsConfig* dns_config_for_testing_;
   const base::Time creation_time_;
   scoped_ptr<internal::DnsConfigServicePosix> dns_config_service_;
   // Used to detect tunnel state changes.
   internal::AddressTrackerLinux address_tracker_;
 
+  // Used only on the calling thread that created this thread.
+  base::WeakPtr<DnsConfigServiceThread> weak_ptr_;
+  base::WeakPtrFactory<DnsConfigServiceThread> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(DnsConfigServiceThread);
 };
 
 NetworkChangeNotifierAndroid::~NetworkChangeNotifierAndroid() {
   delegate_->RemoveObserver(this);
 }
 
 NetworkChangeNotifier::ConnectionType
 NetworkChangeNotifierAndroid::GetCurrentConnectionType() const {
   return delegate_->GetCurrentConnectionType();
@@ skipping 21 matching lines @@
 NetworkChangeNotifierAndroid::NetworkChangeNotifierAndroid(
     NetworkChangeNotifierDelegateAndroid* delegate,
     const DnsConfig* dns_config_for_testing)
     : NetworkChangeNotifier(NetworkChangeCalculatorParamsAndroid()),
       delegate_(delegate),
       dns_config_service_thread_(
           new DnsConfigServiceThread(dns_config_for_testing)) {
   delegate_->AddObserver(this);
   dns_config_service_thread_->StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
-  dns_config_service_thread_->InitAfterStart();
 }
 
 // static
 NetworkChangeNotifier::NetworkChangeCalculatorParams
 NetworkChangeNotifierAndroid::NetworkChangeCalculatorParamsAndroid() {
   NetworkChangeCalculatorParams params;
   // IPAddressChanged is produced immediately prior to ConnectionTypeChanged
   // so delay IPAddressChanged so they get merged with the following
   // ConnectionTypeChanged signal.
   params.ip_address_offline_delay_ = base::TimeDelta::FromSeconds(1);
   params.ip_address_online_delay_ = base::TimeDelta::FromSeconds(1);
   params.connection_type_offline_delay_ = base::TimeDelta::FromSeconds(0);
   params.connection_type_online_delay_ = base::TimeDelta::FromSeconds(0);
   return params;
 }
 
 }  // namespace net