service worker: Bump update time even when the script was identical

content/browser/service_worker/service_worker_job_unittest.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 <stdint.h>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 774 matching lines @@
   ~UpdateJobTestHelper() override {
     if (registration_.get())
       registration_->RemoveListener(this);
   }
 
   ServiceWorkerStorage* storage() { return context()->storage(); }
   ServiceWorkerJobCoordinator* job_coordinator() {
     return context()->job_coordinator();
   }
 
-  bool force_bypass_cache_for_scripts() const {
-    return force_bypass_cache_for_scripts_;
-  }
-  void set_force_bypass_cache_for_scripts(bool force_bypass_cache_for_scripts) {
-    force_bypass_cache_for_scripts_ = force_bypass_cache_for_scripts;
-  }
-
   void set_force_start_worker_failure(bool force_start_worker_failure) {
     force_start_worker_failure_ = force_start_worker_failure;
   }
 
   scoped_refptr<ServiceWorkerRegistration> SetupInitialRegistration(
       const GURL& test_origin) {
     scoped_refptr<ServiceWorkerRegistration> registration;
     bool called = false;
     job_coordinator()->Register(
         test_origin.Resolve(kScope),
@@ skipping 20 matching lines @@
     const uint64_t kMockScriptSize = 19284;
     ServiceWorkerVersion* version = context()->GetLiveVersion(version_id);
     ServiceWorkerRegistration* registration =
         context()->GetLiveRegistration(version->registration_id());
     bool is_update = registration->active_version() &&
                      version != registration->active_version();
 
     ASSERT_TRUE(version);
     version->AddListener(this);
 
-    if (force_bypass_cache_for_scripts())
-      version->set_force_bypass_cache_for_scripts(true);
+    // Simulate network access.
+    base::TimeDelta time_since_last_check =
+        base::Time::Now() - registration->last_update_check();
+    if (!is_update || script.GetOrigin() != kNoChangeOrigin ||
+        time_since_last_check > base::TimeDelta::FromHours(
+                                    kServiceWorkerScriptMaxCacheAgeInHours)) {
+      version->embedded_worker()->OnNetworkAccessedForScriptLoad();
+    }
 
+    int64_t resource_id = storage()->NewResourceId();
+    version->script_cache_map()->NotifyStartedCaching(script, resource_id);
     if (!is_update) {
       // Spoof caching the script for the initial version.
-      int64_t resource_id = storage()->NewResourceId();
-      version->script_cache_map()->NotifyStartedCaching(script, resource_id);
       WriteStringResponse(storage(), resource_id, kMockScriptBody);
       version->script_cache_map()->NotifyFinishedCaching(
           script, kMockScriptSize, net::URLRequestStatus(), std::string());
     } else {
       if (script.GetOrigin() == kNoChangeOrigin) {
-        version->SetStartWorkerStatusCode(SERVICE_WORKER_ERROR_EXISTS);
-        EmbeddedWorkerTestHelper::OnStopWorker(embedded_worker_id);
+        // Simulate fetching the updated script and finding it's identical to
+        // the incumbent.
+        net::URLRequestStatus status =
+            net::URLRequestStatus::FromError(net::ERR_FILE_EXISTS);
+        version->script_cache_map()->NotifyFinishedCaching(
+            script, kMockScriptSize, status, std::string());
+        SimulateWorkerScriptLoaded(embedded_worker_id);
         return;
       }
 
       // Spoof caching the script for the new version.
-      int64_t resource_id = storage()->NewResourceId();
-      version->script_cache_map()->NotifyStartedCaching(script, resource_id);
       WriteStringResponse(storage(), resource_id, "mock_different_script");
       version->script_cache_map()->NotifyFinishedCaching(
           script, kMockScriptSize, net::URLRequestStatus(), std::string());
     }
 
     EmbeddedWorkerTestHelper::OnStartWorker(
         embedded_worker_id, version_id, scope, script, pause_after_download);
   }
 
   void OnResumeAfterDownload(int embedded_worker_id) override {
@@ skipping 31 matching lines @@
     entry.version_id = version->version_id();
     entry.status = version->status();
     state_change_log_.push_back(entry);
   }
 
   scoped_refptr<ServiceWorkerRegistration> registration_;
 
   std::vector<AttributeChangeLogEntry> attribute_change_log_;
   std::vector<StateChangeLogEntry> state_change_log_;
   bool update_found_ = false;
-  bool force_bypass_cache_for_scripts_ = false;
   bool force_start_worker_failure_ = false;
 };
 
 // Helper class for update tests that evicts the active version when the update
 // worker is about to be started.
 class EvictIncumbentVersionHelper : public UpdateJobTestHelper {
  public:
   EvictIncumbentVersionHelper() {}
   ~EvictIncumbentVersionHelper() override {}
 
@@ skipping 69 matching lines @@
   const base::Time kYesterday =
       kToday - base::TimeDelta::FromDays(1) - base::TimeDelta::FromHours(1);
   UpdateJobTestHelper* update_helper = new UpdateJobTestHelper;
   helper_.reset(update_helper);
   scoped_refptr<ServiceWorkerRegistration> registration =
       update_helper->SetupInitialRegistration(kNoChangeOrigin);
   ASSERT_TRUE(registration.get());
 
   registration->AddListener(update_helper);
 
-  // Run an update that does not bypass the network cache. The check time
-  // should not be updated.
+  // Run an update where the script did not change and the network was not
+  // accessed. The check time should not be updated.
   registration->set_last_update_check(kToday);
   registration->active_version()->StartUpdate();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kToday, registration->last_update_check());
+  EXPECT_FALSE(update_helper->update_found_);
+
+  // Run an update where the script did not change and the network was accessed.
+  // The check time should be updated.
+  registration->set_last_update_check(kYesterday);
+  registration->active_version()->StartUpdate();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_LT(kYesterday, registration->last_update_check());
+  EXPECT_FALSE(update_helper->update_found_);
   registration->RemoveListener(update_helper);
 
   registration = update_helper->SetupInitialRegistration(kNewVersionOrigin);
   ASSERT_TRUE(registration.get());
 
   registration->AddListener(update_helper);
 
-  // Run an update that bypasses the network cache. The check time should be
-  // updated.
-  update_helper->set_force_bypass_cache_for_scripts(true);
+  // Run an update where the script changed. The check time should be updated.
   registration->set_last_update_check(kYesterday);
   registration->active_version()->StartUpdate();
   base::RunLoop().RunUntilIdle();
   EXPECT_LT(kYesterday, registration->last_update_check());
 
   // Run an update to a worker that loads successfully but fails to start up
   // (script evaluation failure). The check time should be updated.
-  update_helper->set_force_bypass_cache_for_scripts(true);
   update_helper->set_force_start_worker_failure(true);
   registration->set_last_update_check(kYesterday);
   registration->active_version()->StartUpdate();
   base::RunLoop().RunUntilIdle();
   EXPECT_LT(kYesterday, registration->last_update_check());
 }
 
 TEST_F(ServiceWorkerJobTest, Update_NewVersion) {
   UpdateJobTestHelper* update_helper = new UpdateJobTestHelper;
   helper_.reset(update_helper);
@@ skipping 530 matching lines @@
     ASSERT_TRUE(start_msg);
     EmbeddedWorkerMsg_StartWorker::Param param;
     EmbeddedWorkerMsg_StartWorker::Read(start_msg, &param);
     EmbeddedWorkerMsg_StartWorker_Params start_params = base::get<0>(param);
     EXPECT_TRUE(start_params.pause_after_download);
     sink->ClearMessages();
   }
 }
 
 }  // namespace content