Revert "Revert of Moving gRPC support interfaces out of cronet and into a new component. (patchset …

components/cronet/ios/cronet_environment.cc

 // Copyright 2016 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 "components/cronet/ios/cronet_environment.h"
 
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/atomicops.h"
@@ skipping 78 matching lines @@
 
   cronet::CronetEnvironment* environment_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   DISALLOW_COPY_AND_ASSIGN(CronetURLRequestContextGetter);
 };
 
 }  // namespace
 
 namespace cronet {
 
-bool CronetEnvironment::IsOnNetworkThread() {
-  return network_io_thread_->task_runner()->BelongsToCurrentThread();
-}
-
 void CronetEnvironment::PostToNetworkThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task) {
   network_io_thread_->task_runner()->PostTask(from_here, task);
 }
 
 void CronetEnvironment::PostToFileUserBlockingThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task) {
   file_user_blocking_thread_->task_runner()->PostTask(from_here, task);
@@ skipping 105 matching lines @@
                                     int port,
                                     int alternate_port) {
   DCHECK(port == alternate_port);
   quic_hints_.push_back(net::HostPortPair(host, port));
 }
 
 CronetEnvironment::CronetEnvironment(const std::string& user_agent,
                                      bool user_agent_partial)
     : http2_enabled_(false),
       quic_enabled_(false),
+      event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+             base::WaitableEvent::InitialState::NOT_SIGNALED),
       user_agent_(user_agent),
       user_agent_partial_(user_agent_partial),
       net_log_(new net::NetLog) {}
 
 void CronetEnvironment::Start() {
   // Threads setup.
   network_cache_thread_.reset(new base::Thread("Chrome Network Cache Thread"));
   network_cache_thread_->StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   network_io_thread_.reset(new base::Thread("Chrome Network IO Thread"));
@@ skipping 52 matching lines @@
   main_context_->set_http_server_properties(http_server_properties_.get());
 
   // TODO(rdsmith): Note that the ".release()" calls below are leaking
   // the objects in question; this should be fixed by having an object
   // corresponding to URLRequestContextStorage that actually owns those
   // objects.  See http://crbug.com/523858.
   std::unique_ptr<net::MappedHostResolver> mapped_host_resolver(
       new net::MappedHostResolver(
           net::HostResolver::CreateDefaultResolver(nullptr)));
 
-  mapped_host_resolver->SetRulesFromString(host_resolver_rules_);
   main_context_->set_host_resolver(mapped_host_resolver.release());
 
   if (!cert_verifier_)
     cert_verifier_ = net::CertVerifier::CreateDefault();
   main_context_->set_cert_verifier(cert_verifier_.get());
 
   std::unique_ptr<net::MultiLogCTVerifier> ct_verifier =
       base::MakeUnique<net::MultiLogCTVerifier>();
   ct_verifier->AddLogs(net::ct::CreateLogVerifiersForKnownLogs());
   main_context_->set_cert_transparency_verifier(ct_verifier.release());
@@ skipping 82 matching lines @@
 }
 
 std::vector<uint8_t> CronetEnvironment::GetHistogramDeltas() {
   base::StatisticsRecorder::Initialize();
   std::vector<uint8_t> data;
   if (!HistogramManager::GetInstance()->GetDeltas(&data))
     return std::vector<uint8_t>();
   return data;
 }
 
+void CronetEnvironment::SetHostResolverRules(const std::string& rules) {
+  PostToNetworkThread(
+      FROM_HERE, base::Bind(&CronetEnvironment::SetHostResolverRulesInternal,
+                            base::Unretained(this), rules));
+  event_.Wait();

[mef, 2016/11/07 18:15:20]

Can event be allocated on the stack and passed as a bind argument? It should
remain valid until SetHostResolverRulesInternal completes.

[Garrett Casto, 2016/11/07 18:37:26]

Done.

+}
+
+void CronetEnvironment::SetHostResolverRulesInternal(const std::string& rules) {
+  static_cast<net::MappedHostResolver*>(main_context_->host_resolver())
+      ->SetRulesFromString(rules);
+  event_.Signal();
+}
+
 }  // namespace cronet