[Cronet] Write effective experimental options to NetLog

components/cronet/android/cronet_url_request_context_adapter.h

 // 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.
 
 #ifndef COMPONENTS_CRONET_ANDROID_CRONET_URL_REQUEST_CONTEXT_ADAPTER_H_
 #define COMPONENTS_CRONET_ANDROID_CRONET_URL_REQUEST_CONTEXT_ADAPTER_H_
 
 #include <jni.h>
 #include <stdint.h>
 
@@ skipping 18 matching lines @@
 class TimeTicks;
 }  // namespace base
 
 namespace net {
 class HttpServerPropertiesManager;
 class NetLog;
 class NetworkQualitiesPrefsManager;
 class ProxyConfigService;
 class SdchOwner;
 class URLRequestContext;
-class WriteToFileNetLogObserver;
 class FileNetLogObserver;
 }  // namespace net
 
 namespace cronet {
 class TestUtil;
 
 #if defined(DATA_REDUCTION_PROXY_SUPPORT)
 class CronetDataReductionProxy;
 #endif
 
@@ skipping 25 matching lines @@
 
   // Posts a task that might depend on the context being initialized
   // to the network thread.
   void PostTaskToNetworkThread(const tracked_objects::Location& posted_from,
                                const base::Closure& callback);
 
   bool IsOnNetworkThread() const;
 
   net::URLRequestContext* GetURLRequestContext();
 
+  // TODO(xunjieli): Keep only one version of StartNetLog().
+
   // Starts NetLog logging to file. This can be called on any thread.  Returns
   // false if it fails to open log file.

[mgersh, 2017/03/13 18:31:52]

The comment about return value is out of date now.

[xunjieli, 2017/03/14 13:22:25]

Done.

-  bool StartNetLogToFile(JNIEnv* env,
+  void StartNetLogToFile(JNIEnv* env,
                          const base::android::JavaParamRef<jobject>& jcaller,
                          const base::android::JavaParamRef<jstring>& jfile_name,
                          jboolean jlog_all);
 
   // Starts NetLog logging to disk with a bounded amount of disk space. This
   // can be called on any thread.
   void StartNetLogToDisk(JNIEnv* env,
                          const base::android::JavaParamRef<jobject>& jcaller,
                          const base::android::JavaParamRef<jstring>& jdir_name,
                          jboolean jlog_all,
@@ skipping 94 matching lines @@
   void OnThroughputObservation(
       int32_t throughput_kbps,
       const base::TimeTicks& timestamp,
       net::NetworkQualityObservationSource source) override;
 
   // Same as StartNetLogToDisk, but called only on the network thread.
   void StartNetLogToBoundedFileOnNetworkThread(const std::string& dir_path,
                                                bool include_socket_bytes,
                                                int size);
 
-  // Stops NetLog logging to file by calling StopObserving() and destroying
-  // the |bounded_file_observer_|.
-  void StopBoundedFileNetLogOnNetworkThread();
+  // Same as StartNetLogToFile, but called only on the network thread.
+  void StartNetLogOnNetworkThread(const std::string& file_name,
+                                  bool include_socket_bytes);
+
+  // Stops NetLog logging on the network thread.
+  void StopNetLogOnNetworkThread();
 
   // Callback for StopObserving() that unblocks the Java ConditionVariable and
   // signals that it is safe to access the NetLog files.
   void StopNetLogCompleted();
 
-  // Helper method to stop NetLog logging to file. This can be called on any
-  // thread. This will flush any remaining writes to disk.
-  void StopNetLogHelper();
+  std::unique_ptr<base::DictionaryValue> GetNetLogInfo() const;
 
   // Network thread is owned by |this|, but is destroyed from java thread.
   base::Thread* network_thread_;
 
   // File thread should be destroyed last.
   std::unique_ptr<base::Thread> file_thread_;
 
-  // |write_to_file_observer_| should only be accessed with
-  // |write_to_file_observer_lock_|.
-  std::unique_ptr<net::WriteToFileNetLogObserver> write_to_file_observer_;
-  base::Lock write_to_file_observer_lock_;
-
-  std::unique_ptr<net::FileNetLogObserver> bounded_file_observer_;
+  std::unique_ptr<net::FileNetLogObserver> net_log_file_observer_;
 
   // |pref_service_| should outlive the HttpServerPropertiesManager owned by
   // |context_|.
   std::unique_ptr<PrefService> pref_service_;
   std::unique_ptr<net::URLRequestContext> context_;
   std::unique_ptr<net::ProxyConfigService> proxy_config_service_;
   scoped_refptr<JsonPrefStore> json_pref_store_;
   net::HttpServerPropertiesManager* http_server_properties_manager_;
 
   // |sdch_owner_| should be destroyed before |json_pref_store_|, because
   // tearing down |sdch_owner_| forces |json_pref_store_| to flush pending
   // writes to the disk.
   std::unique_ptr<net::SdchOwner> sdch_owner_;
 
   // Context config is only valid until context is initialized.
   std::unique_ptr<URLRequestContextConfig> context_config_;
 
+  // Effective experimental options. Kept for NetLog.
+  std::unique_ptr<base::DictionaryValue> effective_experimental_options_;
+
   // A queue of tasks that need to be run after context has been initialized.
   std::queue<base::Closure> tasks_waiting_for_context_;
   bool is_context_initialized_;
   int default_load_flags_;
 
   // A network quality estimator.
   std::unique_ptr<net::NetworkQualityEstimator> network_quality_estimator_;
 
   // Manages the writing and reading of the network quality prefs.
   std::unique_ptr<net::NetworkQualitiesPrefsManager>
       network_qualities_prefs_manager_;
 
   // Java object that owns this CronetURLRequestContextAdapter.
   base::android::ScopedJavaGlobalRef<jobject> jcronet_url_request_context_;
 
 #if defined(DATA_REDUCTION_PROXY_SUPPORT)
   std::unique_ptr<CronetDataReductionProxy> data_reduction_proxy_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(CronetURLRequestContextAdapter);
 };
 
 }  // namespace cronet
 
 #endif  // COMPONENTS_CRONET_ANDROID_CRONET_URL_REQUEST_CONTEXT_ADAPTER_H_