[Cronet] Purge storage directory if version does not match

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>
 #include <map>
 #include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
@@ skipping 29 matching lines @@
 #include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_interceptor.h"
 
 #if defined(DATA_REDUCTION_PROXY_SUPPORT)
 #include "components/cronet/android/cronet_data_reduction_proxy.h"
 #endif
 
 namespace {
 
 const char kHttpServerProperties[] = "net.http_server_properties";
+// Current version of disk cache.
+const int32_t kDiskCacheVersion = 1;

[mef, 2016/04/01 18:41:46]

how would we know when to change it?

[xunjieli, 2016/04/01 20:20:04]

If we moved things around, for instance, right now we have:
storage_path/
   disk_cache/
   prefs/
   version

If in the future, we decide that disk_cache should no longer be in a dir named
"disk_cache", and instead, it should be "awesome_disk_cache", then we will
update the version number.

+// Version number used when the version of disk cache is unknown.
+const uint32_t kDiskCacheVersionUnknown = 0;
 
 // Connects the HttpServerPropertiesManager's storage to the prefs.
 class PrefServiceAdapter
     : public net::HttpServerPropertiesManager::PrefDelegate {
  public:
   explicit PrefServiceAdapter(PrefService* pref_service)
       : pref_service_(pref_service), path_(kHttpServerProperties) {
     pref_change_registrar_.Init(pref_service_);
   }
 
@@ skipping 188 matching lines @@
   }
 
   bool OnCanAccessFile(const net::URLRequest& request,
                        const base::FilePath& path) const override {
     return false;
   }
 
   DISALLOW_COPY_AND_ASSIGN(BasicNetworkDelegate);
 };
 
+bool IsCurrentVersion(const base::FilePath& version_filepath) {
+  if (!base::PathExists(version_filepath))
+    return false;
+  base::File version_file(version_filepath,
+                          base::File::FLAG_OPEN | base::File::FLAG_READ);
+  uint32_t version = kDiskCacheVersionUnknown;
+  int bytes_read =
+      version_file.Read(0, reinterpret_cast<char*>(&version), sizeof(version));
+  if (bytes_read != sizeof(version)) {
+    DLOG(WARNING) << "Cannot read from version file.";
+    return false;
+  }
+  return version == kDiskCacheVersion;
+}
+
+// TODO(xunjieli): Handle failures.
+void InitializeCacheDiskCacheDirectory(const base::FilePath& dir) {
+  // Checks version file and remove old versions.
+  base::FilePath version_filepath = dir.Append("version");
+  if (IsCurrentVersion(version_filepath)) {
+    // The version is up-to-date, so there is nothing to do.
+    return;
+  }
+  // Delete old directory recursively and create a new directory.
+  // base::DeleteFile returns true if the directory does not exist, so it is
+  // fine if there is nothing on disk.
+  if (!(base::DeleteFile(dir, true) && base::CreateDirectory(dir))) {

[mef, 2016/04/01 18:41:46]

I think it makes sense to have disk cache directory be a subdirectory of |dir|,
so we could delete just that in the future without deleting prefs and other
stuff.

Ah, I see that it set in config processor. So, maybe rename here
CacheDiskCacheDirectory -> StorageDirectory?

[xunjieli, 2016/04/01 20:20:04]

Done.

+    DLOG(WARNING) << "Cannot purge directory.";
+    return;
+  }
+  base::File new_version_file(version_filepath, base::File::FLAG_CREATE_ALWAYS |
+                                                    base::File::FLAG_WRITE);
+
+  if (!new_version_file.IsValid()) {
+    DLOG(WARNING) << "Cannot create a version file.";
+    return;
+  }
+
+  DCHECK(new_version_file.created());
+  uint32_t new_version = kDiskCacheVersion;
+  int bytes_written = new_version_file.Write(
+      0, reinterpret_cast<char*>(&new_version), sizeof(new_version));
+  if (bytes_written != sizeof(new_version)) {
+    DLOG(WARNING) << "Cannot write to version file.";
+    return;
+  }
+  base::FilePath prefs_dir = dir.Append(FILE_PATH_LITERAL("prefs"));
+  if (!base::CreateDirectory(prefs_dir)) {
+    DLOG(WARNING) << "Cannot create prefs directory";
+    return;
+  }
+}
+
 }  // namespace
 
 namespace cronet {
 
 // Explicitly register static JNI functions.
 bool CronetUrlRequestContextAdapterRegisterJni(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 CronetURLRequestContextAdapter::CronetURLRequestContextAdapter(
@@ skipping 151 matching lines @@
 #endif  // defined(DATA_REDUCTION_PROXY_SUPPORT)
   context_builder.set_network_delegate(std::move(network_delegate));
   context_builder.set_net_log(net_log_.get());
 
   // Android provides a local HTTP proxy server that handles proxying when a PAC
   // URL is present. Create a proxy service without a resolver and rely on this
   // local HTTP proxy. See: crbug.com/432539.
   context_builder.set_proxy_service(
       net::ProxyService::CreateWithoutProxyResolver(
           std::move(proxy_config_service_), net_log_.get()));
+
   config->ConfigureURLRequestContextBuilder(&context_builder, net_log_.get(),
                                             GetFileThread()->task_runner());
 
   // 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"));
+    base::FilePath storage_path(config->storage_path);
+    // Make sure disk cache directory has correct version.
+    InitializeCacheDiskCacheDirectory(storage_path);

[mef, 2016/04/01 18:41:46]

so, what do we do if this fails?

[xunjieli, 2016/04/01 20:20:04]

I believe we will just fail silently. Nothing will crash.

+    base::FilePath filepath =
+        storage_path.Append(FILE_PATH_LITERAL("prefs"))

[mef, 2016/04/01 18:41:46]

can we have a constant for "prefs" directory name?

[xunjieli, 2016/04/01 20:20:04]

Done.

+            .Append(FILE_PATH_LITERAL("local_prefs.json"));

[mef, 2016/04/01 18:41:46]

can we have a constant for "prefs" file name?

[xunjieli, 2016/04/01 20:20:04]

Done.

     json_pref_store_ = new JsonPrefStore(
         filepath, GetFileThread()->task_runner(), scoped_ptr<PrefFilter>());
     context_builder.SetFileTaskRunner(GetFileThread()->task_runner());
 
     // Set up HttpServerPropertiesManager.
     PrefServiceFactory factory;
     factory.set_user_prefs(json_pref_store_);
     scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple());
     registry->RegisterDictionaryPref(kHttpServerProperties,
                                      new base::DictionaryValue());
@@ skipping 346 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