[Cronet] Make StartNetLog and StopNetLog synchronous in Cronet

components/cronet/android/cronet_url_request_context_adapter.cc

 // 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 "components/cronet/android/cronet_url_request_context_adapter.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 378 matching lines @@
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
 
   if (http_server_properties_manager_)
     http_server_properties_manager_->ShutdownOnPrefThread();
   if (pref_service_)
     pref_service_->CommitPendingWrite();
   if (network_quality_estimator_) {
     network_quality_estimator_->RemoveRTTObserver(this);
     network_quality_estimator_->RemoveThroughputObserver(this);
   }
-  StopNetLogOnNetworkThread();
 }
 
 void CronetURLRequestContextAdapter::InitRequestContextOnMainThread(
     JNIEnv* env,
     const JavaParamRef<jobject>& jcaller) {
   base::android::ScopedJavaGlobalRef<jobject> jcaller_ref;
   jcaller_ref.Reset(env, jcaller);
   proxy_config_service_ = net::ProxyService::CreateSystemProxyConfigService(
       GetNetworkTaskRunner(), nullptr /* Ignored on Android */);
   net::ProxyConfigServiceAndroid* android_proxy_config_service =
@@ skipping 287 matching lines @@
 scoped_refptr<base::SingleThreadTaskRunner>
 CronetURLRequestContextAdapter::GetNetworkTaskRunner() const {
   return network_thread_->task_runner();
 }
 
 void CronetURLRequestContextAdapter::StartNetLogToFile(
     JNIEnv* env,
     const JavaParamRef<jobject>& jcaller,
     const JavaParamRef<jstring>& jfile_name,
     jboolean jlog_all) {
-  PostTaskToNetworkThread(
-      FROM_HERE,
-      base::Bind(
-          &CronetURLRequestContextAdapter::StartNetLogToFileOnNetworkThread,
-          base::Unretained(this),
-          base::android::ConvertJavaStringToUTF8(env, jfile_name), jlog_all));
-}
-
-void CronetURLRequestContextAdapter::StopNetLog(
-    JNIEnv* env,
-    const JavaParamRef<jobject>& jcaller) {
-  PostTaskToNetworkThread(
-      FROM_HERE,
-      base::Bind(&CronetURLRequestContextAdapter::StopNetLogOnNetworkThread,
-                 base::Unretained(this)));
-}
-
-void CronetURLRequestContextAdapter::StartNetLogToFileOnNetworkThread(
-    const std::string& file_name, bool log_all) {
-  DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
-  DCHECK(is_context_initialized_);
-  DCHECK(context_);
+  base::AutoLock lock(write_to_file_observer_lock_);
   // Do nothing if already logging to a file.
   if (write_to_file_observer_)
     return;
+  std::string file_name =
+      base::android::ConvertJavaStringToUTF8(env, jfile_name);
   base::FilePath file_path(file_name);
   base::ScopedFILE file(base::OpenFile(file_path, "w"));
   if (!file) {
     LOG(ERROR) << "Failed to open NetLog file for writing.";
     return;
   }
 
   write_to_file_observer_.reset(new net::WriteToFileNetLogObserver());
-  if (log_all) {
+  if (jlog_all == JNI_TRUE) {
     write_to_file_observer_->set_capture_mode(
         net::NetLogCaptureMode::IncludeSocketBytes());
   }
-  write_to_file_observer_->StartObserving(context_->net_log(), std::move(file),
-                                          nullptr, context_.get());
+  write_to_file_observer_->StartObserving(
+      g_net_log.Get().net_log(), std::move(file),
+      /*constants=*/nullptr, /*url_request_context=*/nullptr);
 }
 
-void CronetURLRequestContextAdapter::StopNetLogOnNetworkThread() {
-  DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
+void CronetURLRequestContextAdapter::StopNetLog(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller) {
+  base::AutoLock lock(write_to_file_observer_lock_);
   if (write_to_file_observer_) {
-    write_to_file_observer_->StopObserving(context_.get());
+    write_to_file_observer_->StopObserving(/*url_request_context=*/nullptr);
     write_to_file_observer_.reset();
   }
 }
 
 base::Thread* CronetURLRequestContextAdapter::GetFileThread() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   if (!file_thread_) {
     file_thread_.reset(new base::Thread("Network File Thread"));
     file_thread_->Start();
   }
@@ skipping 142 matching lines @@
     JNIEnv* env,
     const JavaParamRef<jclass>& jcaller) {
   base::StatisticsRecorder::Initialize();
   std::vector<uint8_t> data;
   if (!HistogramManager::GetInstance()->GetDeltas(&data))
     return ScopedJavaLocalRef<jbyteArray>();
   return base::android::ToJavaByteArray(env, &data[0], data.size());
 }
 
 }  // namespace cronet