Offline By Default

services/url_response_disk_cache/url_response_disk_cache_apptest.cc

 // Copyright 2015 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 "base/files/file_util.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/application_test_base.h"
@@ skipping 33 matching lines @@
 
 HttpHeaderPtr RandomEtagHeader() {
   auto etag_header = HttpHeader::New();
   etag_header->name = "ETag";
   etag_header->value = base::StringPrintf("%f", base::RandDouble());
   return etag_header;
 }
 
 }  // namespace
 
-TEST_F(URLResponseDiskCacheAppTest, GetFile) {
+TEST_F(URLResponseDiskCacheAppTest, BaseCache) {
+  const std::string url = "http://www.example.com/1";
+
+  url_response_disk_cache_->Get(
+      url, [](URLResponsePtr url_response, Array<uint8_t> received_file_path,
+              Array<uint8_t> received_cache_dir_path) {
+        EXPECT_FALSE(url_response);
+      });
+  url_response_disk_cache_.WaitForIncomingResponse();
+
   URLResponsePtr url_response = mojo::URLResponse::New();
   url_response->url = "http://www.example.com/1";
   url_response->headers.push_back(RandomEtagHeader());
+  DataPipe pipe;
+  std::string content = base::RandBytesAsString(32);
+  uint32_t num_bytes = content.size();
+  ASSERT_EQ(MOJO_RESULT_OK,
+            WriteDataRaw(pipe.producer_handle.get(), content.c_str(),
+                         &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
+  ASSERT_EQ(content.size(), num_bytes);
+  pipe.producer_handle.reset();
+  url_response->body = pipe.consumer_handle.Pass();
+
+  url_response_disk_cache_->Update(url_response.Pass());
+
+  base::FilePath file;
+  base::FilePath cache_dir;
+
+  // Wait up to 1 second for the cache to be updated.
+  base::Time start = base::Time::Now();
+  while (file.empty() &&
+         ((base::Time::Now() - start) < base::TimeDelta::FromSeconds(1))) {
+    url_response_disk_cache_->Get(
+        url, [&url_response, &file, &cache_dir](
+                 URLResponsePtr response, Array<uint8_t> received_file_path,
+                 Array<uint8_t> received_cache_dir_path) {
+          url_response = response.Pass();
+          file = toPath(received_file_path.Pass());
+          cache_dir = toPath(received_cache_dir_path.Pass());
+        });
+    url_response_disk_cache_.WaitForIncomingResponse();
+  }
+
+  EXPECT_TRUE(url_response);
+  EXPECT_FALSE(file.empty());
+  EXPECT_EQ(url, url_response->url);
+  std::string received_content;
+  ASSERT_TRUE(base::ReadFileToString(file, &received_content));
+  EXPECT_EQ(content, received_content);
+}
+
+TEST_F(URLResponseDiskCacheAppTest, UpdateAndGet) {
+  URLResponsePtr url_response = mojo::URLResponse::New();
+  url_response->url = "http://www.example.com/1";
+  url_response->headers.push_back(RandomEtagHeader());
   DataPipe pipe;
   std::string content = base::RandBytesAsString(32);
   uint32_t num_bytes = content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe.producer_handle.get(), content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(content.size(), num_bytes);
   pipe.producer_handle.reset();
   url_response->body = pipe.consumer_handle.Pass();
   base::FilePath file;
   base::FilePath cache_dir;
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   std::string received_content;
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
   EXPECT_EQ(content, received_content);
 }
 
-TEST_F(URLResponseDiskCacheAppTest, GetExtractedContent) {
+TEST_F(URLResponseDiskCacheAppTest, UpdateAndGetExtracted) {
   URLResponsePtr url_response = mojo::URLResponse::New();
   url_response->url = "http://www.example.com/2";
   url_response->headers.push_back(RandomEtagHeader());
   DataPipe pipe;
   std::string content = base::RandBytesAsString(32);
   uint32_t num_bytes = kTestData.size;
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe.producer_handle.get(), kTestData.data, &num_bytes,
                          MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(kTestData.size, num_bytes);
   pipe.producer_handle.reset();
   url_response->body = pipe.consumer_handle.Pass();
   base::FilePath extracted_dir;
   base::FilePath cache_dir;
-  url_response_disk_cache_->GetExtractedContent(
+  url_response_disk_cache_->UpdateAndGetExtracted(
       url_response.Pass(),
       [&extracted_dir, &cache_dir](Array<uint8_t> received_extracted_dir,
                                    Array<uint8_t> received_cache_dir_path) {
         extracted_dir = toPath(received_extracted_dir.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(extracted_dir.empty());
   base::FilePath file1 = extracted_dir.Append("file1");
   std::string file_content;
@@ skipping 18 matching lines @@
   std::string content = base::RandBytesAsString(32);
   uint32_t num_bytes = content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe1.producer_handle.get(), content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(content.size(), num_bytes);
   pipe1.producer_handle.reset();
   url_response->body = pipe1.consumer_handle.Pass();
   base::FilePath file;
   base::FilePath cache_dir;
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   std::string received_content;
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
@@ skipping 16 matching lines @@
   }
   DataPipe pipe2;
   std::string new_content = base::RandBytesAsString(32);
   num_bytes = new_content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe2.producer_handle.get(), new_content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(new_content.size(), num_bytes);
   pipe2.producer_handle.reset();
   url_response->body = pipe2.consumer_handle.Pass();
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
   EXPECT_EQ(content, received_content);
@@ skipping 10 matching lines @@
   url_response->headers.push_back(RandomEtagHeader());
   DataPipe pipe3;
   new_content = base::RandBytesAsString(32);
   num_bytes = new_content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe3.producer_handle.get(), new_content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(new_content.size(), num_bytes);
   pipe3.producer_handle.reset();
   url_response->body = pipe3.consumer_handle.Pass();
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
   EXPECT_EQ(new_content, received_content);
   saved_file = cache_dir.Append("file");
   EXPECT_FALSE(base::PathExists(saved_file));
   ASSERT_TRUE(base::WriteFile(saved_file, cached_content.data(),
                               cached_content.size()));
 
   // Request using a response without an etag header. Check that the new
   // content is returned, and the cached files is deleted.
   url_response = mojo::URLResponse::New();
   url_response->url = "http://www.example.com/3";
   DataPipe pipe4;
   new_content = base::RandBytesAsString(32);
   num_bytes = new_content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe4.producer_handle.get(), new_content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(new_content.size(), num_bytes);
   pipe4.producer_handle.reset();
   url_response->body = pipe4.consumer_handle.Pass();
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
   EXPECT_EQ(new_content, received_content);
   saved_file = cache_dir.Append("file");
   EXPECT_FALSE(base::PathExists(saved_file));
   ASSERT_TRUE(base::WriteFile(saved_file, cached_content.data(),
                               cached_content.size()));
 
   // Request using a response with an etag header while the cache version
   // doesn't have one. Check that the new content is returned, and the cached
   // files is deleted.
   url_response = mojo::URLResponse::New();
   url_response->url = "http://www.example.com/3";
   DataPipe pipe5;
   new_content = base::RandBytesAsString(32);
   num_bytes = new_content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe5.producer_handle.get(), new_content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(new_content.size(), num_bytes);
   pipe5.producer_handle.reset();
   url_response->body = pipe5.consumer_handle.Pass();
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
   EXPECT_EQ(new_content, received_content);
   saved_file = cache_dir.Append("file");
   EXPECT_FALSE(base::PathExists(saved_file));
 }
 
 }  // namespace mojo