Update installed ServiceWorkers.

content/browser/service_worker/service_worker_storage_unittest.cc

 // Copyright 2013 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 <string>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 65 matching lines @@
 ServiceWorkerStorage::GetAllRegistrationInfosCallback MakeGetAllCallback(
     bool* was_called,
     std::vector<ServiceWorkerRegistrationInfo>* all) {
   return base::Bind(&GetAllCallback, was_called, all);
 }
 
 void OnIOComplete(int* rv_out, int rv) {
   *rv_out = rv;
 }
 
-void WriteBasicResponse(ServiceWorkerStorage* storage, int64 id) {
+void OnCompareComplete(
+    ServiceWorkerStatusCode* status_out, bool* are_equal_out,
+    ServiceWorkerStatusCode status, bool are_equal) {
+  *status_out = status;
+  *are_equal_out = are_equal;
+}
+
+void WriteResponse(
+    ServiceWorkerStorage* storage, int64 id,
+    const std::string& headers,
+    IOBuffer* body, int length) {
   scoped_ptr<ServiceWorkerResponseWriter> writer =
       storage->CreateResponseWriter(id);
 
-  const char kHttpHeaders[] =
-      "HTTP/1.0 200 HONKYDORY\0Content-Length: 6\0\0";
-  const char kHttpBody[] = "Hello\0";
-  scoped_refptr<IOBuffer> body(new WrappedIOBuffer(kHttpBody));
-  std::string raw_headers(kHttpHeaders, arraysize(kHttpHeaders));
   scoped_ptr<net::HttpResponseInfo> info(new net::HttpResponseInfo);
   info->request_time = base::Time::Now();
   info->response_time = base::Time::Now();
   info->was_cached = false;
-  info->headers = new net::HttpResponseHeaders(raw_headers);
+  info->headers = new net::HttpResponseHeaders(headers);
   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer =
       new HttpResponseInfoIOBuffer(info.release());
 
   int rv = -1234;
   writer->WriteInfo(info_buffer, base::Bind(&OnIOComplete, &rv));
   base::RunLoop().RunUntilIdle();
   EXPECT_LT(0, rv);
 
   rv = -1234;
-  writer->WriteData(body, arraysize(kHttpBody),
-                    base::Bind(&OnIOComplete, &rv));
+  writer->WriteData(body, length, base::Bind(&OnIOComplete, &rv));
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(static_cast<int>(arraysize(kHttpBody)), rv);
+  EXPECT_EQ(length, rv);
+}
+
+void WriteStringResponse(
+    ServiceWorkerStorage* storage, int64 id,
+    const std::string& headers,
+    const std::string& body) {
+  scoped_refptr<IOBuffer> body_buffer(new WrappedIOBuffer(body.data()));
+  WriteResponse(storage, id, headers, body_buffer, body.length());
+}
+
+void WriteBasicResponse(ServiceWorkerStorage* storage, int64 id) {
+  scoped_ptr<ServiceWorkerResponseWriter> writer =
+      storage->CreateResponseWriter(id);
+
+  const char kHttpHeaders[] = "HTTP/1.0 200 HONKYDORY\0Content-Length: 5\0\0";
+  const char kHttpBody[] = "Hello";
+  std::string headers(kHttpHeaders, arraysize(kHttpHeaders));
+  WriteStringResponse(storage, id, headers, std::string(kHttpBody));
 }
 
 bool VerifyBasicResponse(ServiceWorkerStorage* storage, int64 id,
                          bool expected_positive_result) {
-  const char kExpectedHttpBody[] = "Hello\0";
+  const std::string kExpectedHttpBody("Hello");
   scoped_ptr<ServiceWorkerResponseReader> reader =
       storage->CreateResponseReader(id);
   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer =
       new HttpResponseInfoIOBuffer();
   {
     TestCompletionCallback cb;
     reader->ReadInfo(info_buffer, cb.callback());
     int rv = cb.WaitForResult();
     if (expected_positive_result)
       EXPECT_LT(0, rv);
     if (rv <= 0)
       return false;
   }
 
-  const int kBigEnough = 512;
-  scoped_refptr<net::IOBuffer> buffer = new IOBuffer(kBigEnough);
+  std::string received_body;
   {
+    const int kBigEnough = 512;
+    scoped_refptr<net::IOBuffer> buffer = new IOBuffer(kBigEnough);
     TestCompletionCallback cb;
     reader->ReadData(buffer, kBigEnough, cb.callback());
     int rv = cb.WaitForResult();
-    EXPECT_EQ(static_cast<int>(arraysize(kExpectedHttpBody)), rv);
+    EXPECT_EQ(static_cast<int>(kExpectedHttpBody.size()), rv);
     if (rv <= 0)
       return false;
+    received_body.assign(buffer->data(), rv);
   }
 
   bool status_match =
       std::string("HONKYDORY") ==
           info_buffer->http_info->headers->GetStatusText();
-  bool data_match =
-      std::string(kExpectedHttpBody) == std::string(buffer->data());
+  bool data_match = kExpectedHttpBody == received_body;
 
   EXPECT_TRUE(status_match);
   EXPECT_TRUE(data_match);
   return status_match && data_match;
 }
 
+void WriteResponseOfSize(ServiceWorkerStorage* storage, int64 id,
+                         char val, int size) {
+  const char kHttpHeaders[] = "HTTP/1.0 200 HONKYDORY\00";
+  std::string headers(kHttpHeaders, arraysize(kHttpHeaders));
+  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(size);
+  memset(buffer->data(), val, size);
+  WriteResponse(storage, id, headers, buffer, size);
+}
+
 }  // namespace
 
 class ServiceWorkerStorageTest : public testing::Test {
  public:
   ServiceWorkerStorageTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {
   }
 
   virtual void SetUp() OVERRIDE {
     context_.reset(
@@ skipping 761 matching lines @@
       live_registration2, NULL, SERVICE_WORKER_OK);
   storage()->NotifyDoneInstallingRegistration(
       live_registration3, NULL, SERVICE_WORKER_OK);
 
   // Find a registration among installed ones.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_EQ(live_registration2, found_registration);
 }
 
+TEST_F(ServiceWorkerStorageTest, CompareResources) {
+  // Compare two small responses containing the same data.
+  WriteBasicResponse(storage(), 1);
+  WriteBasicResponse(storage(), 2);
+  ServiceWorkerStatusCode status = static_cast<ServiceWorkerStatusCode>(-1);
+  bool are_equal = false;
+  storage()->CompareScriptResources(
+      1, 2,
+      base::Bind(&OnCompareComplete, &status, &are_equal));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(SERVICE_WORKER_OK, status);
+  EXPECT_TRUE(are_equal);
+
+  // Compare two small responses with different data.
+  const char kHttpHeaders[] = "HTTP/1.0 200 HONKYDORY\0\0";
+  const char kHttpBody[] = "Goodbye";
+  std::string headers(kHttpHeaders, arraysize(kHttpHeaders));
+  WriteStringResponse(storage(), 3, headers, std::string(kHttpBody));
+  status = static_cast<ServiceWorkerStatusCode>(-1);
+  are_equal = true;
+  storage()->CompareScriptResources(
+      1, 3,
+      base::Bind(&OnCompareComplete, &status, &are_equal));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(SERVICE_WORKER_OK, status);
+  EXPECT_FALSE(are_equal);
+
+  // Compare two large responses with the same data.
+  const int k32K = 32 * 1024;
+  WriteResponseOfSize(storage(), 4, 'a', k32K);
+  WriteResponseOfSize(storage(), 5, 'a', k32K);
+  status = static_cast<ServiceWorkerStatusCode>(-1);
+  are_equal = false;
+  storage()->CompareScriptResources(
+      4, 5,
+      base::Bind(&OnCompareComplete, &status, &are_equal));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(SERVICE_WORKER_OK, status);
+  EXPECT_TRUE(are_equal);
+
+  // Compare a large and small response.
+  status = static_cast<ServiceWorkerStatusCode>(-1);
+  are_equal = true;
+  storage()->CompareScriptResources(
+      1, 5,
+      base::Bind(&OnCompareComplete, &status, &are_equal));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(SERVICE_WORKER_OK, status);
+  EXPECT_FALSE(are_equal);
+
+  // Compare two large responses with different data.
+  WriteResponseOfSize(storage(), 6, 'b', k32K);
+  status = static_cast<ServiceWorkerStatusCode>(-1);
+  are_equal = true;
+  storage()->CompareScriptResources(
+      5, 6,
+      base::Bind(&OnCompareComplete, &status, &are_equal));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(SERVICE_WORKER_OK, status);
+  EXPECT_FALSE(are_equal);
+}
+
 }  // namespace content