Service Worker: Coalesce the start worker timer into the timeout timer.

content/browser/service_worker/service_worker_version.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 298 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerVersionBrowserTest,
                            TimeoutStartingWorker);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerVersionBrowserTest,
                            TimeoutWorkerInEvent);
   friend class ServiceWorkerVersionBrowserTest;
 
   typedef ServiceWorkerVersion self;
   typedef std::map<ServiceWorkerProviderHost*, int> ControlleeMap;
   typedef IDMap<ServiceWorkerProviderHost> ControlleeByIDMap;
 
+  enum PingState { NOT_PINGING, PINGING, PING_TIMED_OUT };
+
+  // Timeout for the worker to start.
+  static const int kStartWorkerTimeoutMinutes;
+
   ~ServiceWorkerVersion() override;
 
   // EmbeddedWorkerInstance::Listener overrides:
   void OnScriptLoaded() override;
   void OnStarted() override;
   void OnStopped(EmbeddedWorkerInstance::Status old_status) override;
   void OnReportException(const base::string16& error_message,
                          int line_number,
                          int column_number,
                          const GURL& source_url) override;
@@ skipping 64 matching lines @@
 
   // The timeout timer periodically calls OnTimeoutTimer, which stops the worker
   // if it is excessively idle or unresponsive to ping.
   void StartTimeoutTimer();
   void StopTimeoutTimer();
   void OnTimeoutTimer();
 
   // The ping protocol is for terminating workers that are taking excessively
   // long executing JavaScript (e.g., stuck in while(true) {}). Periodically a
   // ping IPC is sent to the worker context and if we timeout waiting for a
-  // pong, the worker is terminated.
+  // pong, the worker is terminated. Pinging starts after the script is loaded.
   void PingWorker();
   void OnPingTimeout();
 
   // Stops the worker if it is idle (has no in-flight requests) or timed out
   // ping.
   void StopWorkerIfIdle();
   bool HasInflightRequests() const;
 
-  // ScheduleStartWorkerTimeout is called when attempting to the start the
-  // embedded worker. It sets a timer for calling OnStartWorkerTimeout, which
-  // invokes start callbacks with ERROR_TIMEOUT. It also adds its own start
-  // callback RecordStartWorkerResult which cancels the timer and records
-  // metrics about startup.
-  void ScheduleStartWorkerTimeout();
+  // RecordStartWorkerResult is added as a start callback by StartTimeoutTimer
+  // and records metrics about startup.
   void RecordStartWorkerResult(ServiceWorkerStatusCode status);
-  void OnStartWorkerTimeout();
 
   void DoomInternal();
 
   template <typename IDMAP>
   void RemoveCallbackAndStopIfDoomed(IDMAP* callbacks, int request_id);
 
   const int64 version_id_;
   int64 registration_id_;
   GURL script_url_;
   GURL scope_;
@@ skipping 19 matching lines @@
   std::set<const ServiceWorkerURLRequestJob*> streaming_url_request_jobs_;
 
   ControlleeMap controllee_map_;
   ControlleeByIDMap controllee_by_id_;
   // Will be null while shutting down.
   base::WeakPtr<ServiceWorkerContextCore> context_;
   ObserverList<Listener> listeners_;
   ServiceWorkerScriptCacheMap script_cache_map_;
   base::OneShotTimer<ServiceWorkerVersion> update_timer_;
 
-  // Starts running when the script is loaded (which means it is about to begin
-  // evaluation) and continues until the worker is stopped or a stop request is
-  // ignored because DevTools is attached.
+  // Starts running in StartWorker and continues until the worker is stopped.
   base::RepeatingTimer<ServiceWorkerVersion> timeout_timer_;
   // Holds the time the worker last started being considered idle.
   base::TimeTicks idle_time_;
   // Holds the time that an outstanding ping was sent to the worker.
   base::TimeTicks ping_time_;
-  // True if the worker was stopped because it did not respond to ping in time.
-  bool ping_timed_out_;
-
-  base::OneShotTimer<ServiceWorkerVersion> start_worker_timeout_timer_;
-  base::TimeTicks start_timing_;
+  // The state of the ping protocol.
+  PingState ping_state_;
+  // Holds the time that the outstanding StartWorker() request started.
+  base::TimeTicks start_time_;
 
   bool is_doomed_;
   std::vector<int> pending_skip_waiting_requests_;
   bool skip_waiting_;
   scoped_ptr<net::HttpResponseInfo> main_script_http_info_;
 
   base::WeakPtrFactory<ServiceWorkerVersion> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersion);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_