[cronet] make startNetLogToFile write to correct file

components/cronet/ios/cronet_environment.mm

 // 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 117 matching lines @@
   DCHECK(!base::MessageLoop::current());
   DCHECK(!g_main_message_loop);
   g_main_message_loop = new base::MessageLoopForUI();
   base::MessageLoopForUI::current()->Attach();
   // The network change notifier must be initialized so that registered
   // delegates will receive callbacks.
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = net::NetworkChangeNotifier::Create();
 }
 
-void CronetEnvironment::StartNetLog(base::FilePath::StringType file_name,
+bool CronetEnvironment::StartNetLog(base::FilePath::StringType file_name,
                                     bool log_bytes) {
-  DCHECK(file_name.length());
-  PostToNetworkThread(FROM_HERE,
-                      base::Bind(&CronetEnvironment::StartNetLogOnNetworkThread,
-                                 base::Unretained(this), file_name, log_bytes));
+  if (!file_name.length())
+    return false;
+
+  base::FilePath path(file_name);
+
+  base::ScopedFILE file(base::OpenFile(path, "w"));
+  if (!file) {
+    LOG(ERROR) << "Can not start NetLog to " << path.value() << ": "
+               << strerror(errno);
+    return false;
+  }
+
+  LOG(WARNING) << "Starting NetLog to " << path.value();
+  PostToNetworkThread(
+      FROM_HERE,
+      base::Bind(&CronetEnvironment::StartNetLogOnNetworkThread,
+                 base::Unretained(this), base::Passed(&file), log_bytes));
+
+  return true;
 }
 
-void CronetEnvironment::StartNetLogOnNetworkThread(
-    const base::FilePath::StringType& file_name,
-    bool log_bytes) {
-  DCHECK(file_name.length());
+void CronetEnvironment::StartNetLogOnNetworkThread(base::ScopedFILE file,
+                                                   bool log_bytes) {
   DCHECK(net_log_);
 
   if (net_log_observer_)
     return;
 
-  base::FilePath files_root;
-  if (!PathService::Get(base::DIR_HOME, &files_root))
-    return;
-
-  base::FilePath full_path = files_root.Append(file_name);
-  base::ScopedFILE file(base::OpenFile(full_path, "w"));
-  if (!file) {
-    LOG(ERROR) << "Can not start NetLog to " << full_path.value();
-    return;
-  }
-
   net::NetLogCaptureMode capture_mode =
       log_bytes ? net::NetLogCaptureMode::IncludeSocketBytes()
                 : net::NetLogCaptureMode::Default();
 
   net_log_observer_.reset(new net::WriteToFileNetLogObserver());
   net_log_observer_->set_capture_mode(capture_mode);
   net_log_observer_->StartObserving(main_context_->net_log(), std::move(file),
                                     nullptr, main_context_.get());
-  LOG(WARNING) << "Started NetLog to " << full_path.value();
+  LOG(WARNING) << "Started NetLog";
 }
 
 void CronetEnvironment::StopNetLog() {
   base::WaitableEvent log_stopped_event(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   PostToNetworkThread(FROM_HERE,
                       base::Bind(&CronetEnvironment::StopNetLogOnNetworkThread,
                                  base::Unretained(this), &log_stopped_event));
   log_stopped_event.Wait();
@@ skipping 42 matching lines @@
   network_io_thread_->StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   file_thread_.reset(new base::Thread("Chrome File Thread"));
   file_thread_->StartWithOptions(
       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));
 
-  static bool ssl_key_log_file_set = false;
-  if (!ssl_key_log_file_set && !ssl_key_log_file_name_.empty()) {
-    ssl_key_log_file_set = true;
-    base::FilePath ssl_key_log_file;
-    if (!PathService::Get(base::DIR_HOME, &ssl_key_log_file))
-      return;
-    net::SSLClientSocket::SetSSLKeyLogFile(
-        ssl_key_log_file.Append(ssl_key_log_file_name_),
-        file_thread_->task_runner());
-  }
-
   main_context_getter_ = new CronetURLRequestContextGetter(
       this, network_io_thread_->task_runner());
   base::subtle::MemoryBarrier();
   PostToNetworkThread(FROM_HERE,
                       base::Bind(&CronetEnvironment::InitializeOnNetworkThread,
                                  base::Unretained(this)));
 }
 
 CronetEnvironment::~CronetEnvironment() {
   // net::HTTPProtocolHandlerDelegate::SetInstance(nullptr);
 }
 
 void CronetEnvironment::InitializeOnNetworkThread() {
   DCHECK(network_io_thread_->task_runner()->BelongsToCurrentThread());
   base::FeatureList::InitializeInstance(std::string(), std::string());
 
+  static bool ssl_key_log_file_set = false;
+  if (!ssl_key_log_file_set && !ssl_key_log_file_name_.empty()) {
+    ssl_key_log_file_set = true;
+    base::FilePath ssl_key_log_file;
+    if (!PathService::Get(base::DIR_HOME, &ssl_key_log_file))
+      return;
+    net::SSLClientSocket::SetSSLKeyLogFile(
+        ssl_key_log_file.Append(ssl_key_log_file_name_),
+        file_thread_->task_runner());
+  }
+
   if (user_agent_partial_)
     user_agent_ = web::BuildUserAgentFromProduct(user_agent_);
 
   // Cache
   base::FilePath cache_path;
   if (!PathService::Get(base::DIR_CACHE, &cache_path))
     return;
   cache_path = cache_path.Append(FILE_PATH_LITERAL("cronet"));
 
   std::unique_ptr<URLRequestContextConfig> config(new URLRequestContextConfig(
@@ skipping 92 matching lines @@
   event->Signal();
 }
 
 std::string CronetEnvironment::getDefaultQuicUserAgentId() const {
   return base::SysNSStringToUTF8([[NSBundle mainBundle]
              objectForInfoDictionaryKey:@"CFBundleDisplayName"]) +
          " Cronet/" + CRONET_VERSION;
 }
 
 }  // namespace cronet