[Cronet] Enable persistence mode for Sdch

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 "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
+#include "base/prefs/pref_filter.h"
 #include "base/single_thread_task_runner.h"
 #include "base/values.h"
 #include "components/cronet/url_request_context_config.h"
 #include "jni/CronetUrlRequestContext_jni.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/log/write_to_file_net_log_observer.h"
 #include "net/proxy/proxy_service.h"
@@ skipping 154 matching lines @@
         data_reduction_proxy_->CreateNetworkDelegate(network_delegate.Pass());
     ScopedVector<net::URLRequestInterceptor> interceptors;
     interceptors.push_back(data_reduction_proxy_->CreateInterceptor());
     context_builder.SetInterceptors(interceptors.Pass());
   }
 #endif  // defined(DATA_REDUCTION_PROXY_SUPPORT)
   context_builder.set_network_delegate(network_delegate.release());
   context_builder.set_net_log(net_log.release());
   context_builder.set_proxy_config_service(proxy_config_service_.release());
   config->ConfigureURLRequestContextBuilder(&context_builder);
+
+  // Set up pref file if storage path is specified.
+  if (!config->storage_path.empty()) {
+    base::FilePath filepath(config->storage_path);
+    filepath = filepath.Append(FILE_PATH_LITERAL("local_prefs.json"));
+    if (!file_thread_) {
+      file_thread_.reset(new base::Thread("Network File Thread"));
+      file_thread_->Start();
+    }
+    json_pref_store_ = new JsonPrefStore(filepath, file_thread_->task_runner(),
+                                         scoped_ptr<PrefFilter>());
+    json_pref_store_->ReadPrefsAsync(nullptr);
+    context_builder.SetFileTaskRunner(file_thread_->task_runner());
+  }
+
   context_.reset(context_builder.Build());
 
   default_load_flags_ = net::LOAD_DO_NOT_SAVE_COOKIES |
                         net::LOAD_DO_NOT_SEND_COOKIES;
   if (config->load_disable_cache)
     default_load_flags_ |= net::LOAD_DISABLE_CACHE;
 
   if (config->enable_sdch) {
     DCHECK(context_->sdch_manager());
     sdch_owner_.reset(
         new net::SdchOwner(context_->sdch_manager(), context_.get()));
+    if (json_pref_store_)
+      sdch_owner_->EnablePersistentStorage(json_pref_store_.get());
   }
 
   // Currently (circa M39) enabling QUIC requires setting probability threshold.
   if (config->enable_quic) {
     context_->http_server_properties()
         ->SetAlternativeServiceProbabilityThreshold(0.0f);
     for (auto hint = config->quic_hints.begin();
          hint != config->quic_hints.end(); ++hint) {
       const URLRequestContextConfig::QuicHint& quic_hint = **hint;
       if (quic_hint.host.empty()) {
@@ skipping 42 matching lines @@
     data_reduction_proxy_->Init(true, GetURLRequestContext());
 #endif
   is_context_initialized_ = true;
   while (!tasks_waiting_for_context_.empty()) {
     tasks_waiting_for_context_.front().Run();
     tasks_waiting_for_context_.pop();
   }
 }
 
 void CronetURLRequestContextAdapter::Destroy(JNIEnv* env, jobject jcaller) {
   DCHECK(!GetNetworkTaskRunner()->BelongsToCurrentThread());

[mef, 2015/05/15 14:30:39]

Is there some way to flush json_pref_store_ here? 
My concern is that file thread will go away soon, so it needs to process write
tasks (possibly added in json_pref_store_ destructor) while it is alive.

[xunjieli, 2015/05/15 16:28:03]

Since Destroy is called on a Java thread, and
JsonPrefStore::CommitPendingWrite() asserts that it is called on the network
thread, I can't do it here. I can make a separate DestroyOnNetworkThread method,
but I wonder whether this is worth the effort. The destructor of JsonPrefStore
already calls CommitPendingWrite(), and the write task is posted before file
thread gets destroyed, the file thread will wait for the task to be executed
right ?

[mef, 2015/05/19 21:39:43]

I think you are right, thanks for explanation!

   // Stick network_thread_ in a local, as |this| may be destroyed from the
   // network thread before delete network_thread is called.
   base::Thread* network_thread = network_thread_;
   GetNetworkTaskRunner()->DeleteSoon(FROM_HERE, this);
   // Deleting thread stops it after all tasks are completed.
   delete network_thread;
 }
 
 net::URLRequestContext* CronetURLRequestContextAdapter::GetURLRequestContext() {
   if (!context_) {
@@ skipping 98 matching lines @@
 }
 
 static jint SetMinLogLevel(JNIEnv* env, jclass jcaller, jint jlog_level) {
   jint old_log_level = static_cast<jint>(logging::GetMinLogLevel());
   // MinLogLevel is global, shared by all URLRequestContexts.
   logging::SetMinLogLevel(static_cast<int>(jlog_level));
   return old_log_level;
 }
 
 }  // namespace cronet