Service Worker: Change the criteria for bumping the last update check time

content/browser/service_worker/embedded_worker_test_helper.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_TEST_HELPER_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_TEST_HELPER_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 73 matching lines @@
     return render_process_host_.get();
   }
 
   TestBrowserContext* browser_context() { return browser_context_.get(); }
 
  protected:
   // Called when StartWorker, StopWorker and SendMessageToWorker message
   // is sent to the embedded worker. Override if necessary. By default
   // they verify given parameters and:
   // - OnStartWorker calls SimulateWorkerStarted
+  // - OnStartWorkerFailed calls SimulateWorkerScriptEvaluated with |success|
+  // false
   // - OnStopWorker calls SimulateWorkerStoped
   // - OnSendMessageToWorker calls the message's respective On*Event handler
   virtual void OnStartWorker(int embedded_worker_id,
                              int64 service_worker_version_id,
                              const GURL& scope,
                              const GURL& script_url);
+  virtual void OnStartWorkerFailed(int embedded_worker_id,

[falken, 2015/12/17 13:23:43]

Sorry to nitpick a bit late in the game... this function is quite different than
the rest in this class, which just do the success thing. Tests that want custom
implementation are supposed to subclass this class.

The name is a bit off too, these are designed to be called in response to a
message from the browser, the browser wouldn't send a "OnStartWorkerFailed"
message. The failure hasn't occurred yet until the function runs.

So I think this custom implementation should be done in a subclass of
EmbeddedWorkerTestHelper.

[jungkees, 2015/12/23 03:08:58]

I'd tried subclassing EmbeddedWorkerTestHelper to override OnStartWorker for the
fail-to-start-worker case. But that needed OnStartWorker to extend the parameter
list (|success| to be passed to SimulateWorkerScriptEvaluated) and involved some
changes in other call sites as such.

So, I instead gave a try with subclassing UpdateJobTestHelper and override
OnStartWorker in that class which simulate the fail-to-start-worker depending on
the value its |force_start_worker_failure_|.

+                                   int64 service_worker_version_id,
+                                   const GURL& scope,
+                                   const GURL& script_url);
   virtual void OnStopWorker(int embedded_worker_id);
   virtual bool OnMessageToWorker(int thread_id,
                                  int embedded_worker_id,
                                  const IPC::Message& message);
 
   // On*Event handlers. Called by the default implementation of
   // OnMessageToWorker when events are sent to the embedded
   // worker. By default they just return success via
   // SimulateSendReplyToBrowser.
   virtual void OnActivateEvent(int embedded_worker_id, int request_id);
   virtual void OnInstallEvent(int embedded_worker_id, int request_id);
   virtual void OnFetchEvent(int embedded_worker_id,
                             int request_id,
                             const ServiceWorkerFetchRequest& request);
   virtual void OnPushEvent(int embedded_worker_id,
                            int request_id,
                            const std::string& data);
 
   // These functions simulate sending an EmbeddedHostMsg message to the
   // browser.
   void SimulateWorkerReadyForInspection(int embedded_worker_id);
   void SimulateWorkerScriptCached(int embedded_worker_id);
   void SimulateWorkerScriptLoaded(int embedded_worker_id);
   void SimulateWorkerThreadStarted(int thread_id, int embedded_worker_id);
-  void SimulateWorkerScriptEvaluated(int embedded_worker_id);
+  void SimulateWorkerScriptEvaluated(int embedded_worker_id, bool success);
   void SimulateWorkerStarted(int embedded_worker_id);
   void SimulateWorkerStopped(int embedded_worker_id);
   void SimulateSend(IPC::Message* message);
 
   EmbeddedWorkerRegistry* registry();
 
  private:
   void OnStartWorkerStub(const EmbeddedWorkerMsg_StartWorker_Params& params);
   void OnStopWorkerStub(int embedded_worker_id);
   void OnMessageToWorkerStub(int thread_id,
@@ skipping 27 matching lines @@
       message_port_message_filters_;
 
   base::WeakPtrFactory<EmbeddedWorkerTestHelper> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerTestHelper);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_TEST_HELPER_H_