#ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
#define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
+#include <map>
+#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/id_map.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
+#include "base/observer_list.h"
+#include "base/timer/timer.h"
#include "content/browser/service_worker/embedded_worker_instance.h"
+#include "content/browser/service_worker/service_worker_cache_listener.h"
+#include "content/browser/service_worker/service_worker_script_cache_map.h"
#include "content/common/content_export.h"
#include "content/common/service_worker/service_worker_status_code.h"
#include "content/common/service_worker/service_worker_types.h"
+#include "third_party/WebKit/public/platform/WebGeofencingEventType.h"
+#include "third_party/WebKit/public/platform/WebServiceWorkerEventResult.h"
class GURL;
+namespace blink {
+struct WebCircularGeofencingRegion;
+}
+
namespace content {
class EmbeddedWorkerRegistry;
+class ServiceWorkerContextCore;
+class ServiceWorkerProviderHost;
class ServiceWorkerRegistration;
class ServiceWorkerVersionInfo;
// This class corresponds to a specific version of a ServiceWorker
// script for a given pattern. When a script is upgraded, there may be
// more than one ServiceWorkerVersion "running" at a time, but only
-// one of them is active. This class connects the actual script with a
+// one of them is activated. This class connects the actual script with a
// running worker.
-//
-// is_shutdown_ detects the live-ness of the object itself. If the object is
-// shut down, then it is in the process of being deleted from memory.
-// This happens when a version is replaced as well as at browser shutdown.
class CONTENT_EXPORT ServiceWorkerVersion
: NON_EXPORTED_BASE(public base::RefCounted<ServiceWorkerVersion>),
- public EmbeddedWorkerInstance::Observer {
+ public EmbeddedWorkerInstance::Listener {
public:
typedef base::Callback<void(ServiceWorkerStatusCode)> StatusCallback;
typedef base::Callback<void(ServiceWorkerStatusCode,
STOPPING = EmbeddedWorkerInstance::STOPPING,
};
- // Current version status; some of the status (e.g. INSTALLED and ACTIVE)
+ // Current version status; some of the status (e.g. INSTALLED and ACTIVATED)
// should be persisted unlike running status.
enum Status {
NEW, // The version is just created.
INSTALLING, // Install event is dispatched and being handled.
INSTALLED, // Install event is finished and is ready to be activated.
ACTIVATING, // Activate event is dispatched and being handled.
- ACTIVE, // Activation is finished and can run as active.
- DEACTIVATED, // The version is no longer running as active, due to
- // unregistration or replace. (TODO(kinuko): we may need
- // different states for different termination sequences)
+ ACTIVATED, // Activation is finished and can run as activated.
+ REDUNDANT, // The version is no longer running as activated, due to
+ // unregistration or replace.
+ };
+
+ class Listener {
+ public:
+ virtual void OnWorkerStarted(ServiceWorkerVersion* version) {}
+ virtual void OnWorkerStopped(ServiceWorkerVersion* version) {}
+ virtual void OnVersionStateChanged(ServiceWorkerVersion* version) {}
+ virtual void OnErrorReported(ServiceWorkerVersion* version,
+ const base::string16& error_message,
+ int line_number,
+ int column_number,
+ const GURL& source_url) {}
+ virtual void OnReportConsoleMessage(ServiceWorkerVersion* version,
+ int source_identifier,
+ int message_level,
+ const base::string16& message,
+ int line_number,
+ const GURL& source_url) {}
+ // Fires when a version transitions from having a controllee to not.
+ virtual void OnNoControllees(ServiceWorkerVersion* version) {}
+
+ protected:
+ virtual ~Listener() {}
};
ServiceWorkerVersion(
ServiceWorkerRegistration* registration,
- EmbeddedWorkerRegistry* worker_registry,
- int64 version_id);
+ const GURL& script_url,
+ int64 version_id,
+ base::WeakPtr<ServiceWorkerContextCore> context);
int64 version_id() const { return version_id_; }
-
- void Shutdown();
- bool is_shutdown() const { return is_shutdown_; }
-
+ int64 registration_id() const { return registration_id_; }
+ const GURL& script_url() const { return script_url_; }
+ const GURL& scope() const { return scope_; }
RunningStatus running_status() const {
return static_cast<RunningStatus>(embedded_worker_->status());
}
-
ServiceWorkerVersionInfo GetInfo();
-
Status status() const { return status_; }
// This sets the new status and also run status change callbacks
void StartWorker(const StatusCallback& callback);
// Starts an embedded worker for this version.
+ // |pause_after_download| notifies worker to pause after download finished
+ // which could be resumed by EmbeddedWorkerInstance::ResumeAfterDownload.
+ // This returns OK (success) if the worker is already running.
+ void StartWorker(bool pause_after_download,
+ const StatusCallback& callback);
+
+ // Stops an embedded worker for this version.
// This returns OK (success) if the worker is already stopped.
void StopWorker(const StatusCallback& callback);
+ // Schedules an update to be run 'soon'.
+ void ScheduleUpdate();
+
+ // If an update is scheduled but not yet started, this resets the timer
+ // delaying the start time by a 'small' amount.
+ void DeferScheduledUpdate();
+
+ // Starts an update now.
+ void StartUpdate();
+
// Sends an IPC message to the worker.
// If the worker is not running this first tries to start it by
// calling StartWorker internally.
// |callback| can be null if the sender does not need to know if the
// message is successfully sent or not.
- // (If the sender expects the receiver to respond please use
- // SendMessageAndRegisterCallback instead)
void SendMessage(const IPC::Message& message, const StatusCallback& callback);
- // Sends an IPC message to the worker and registers |callback| to
- // be notified when a response message is received.
- // The |callback| will be also fired with an error code if the worker
- // is unexpectedly (being) stopped.
- // If the worker is not running this first tries to start it by
- // calling StartWorker internally.
- void SendMessageAndRegisterCallback(const IPC::Message& message,
- const MessageCallback& callback);
-
// Sends install event to the associated embedded worker and asynchronously
- // calls |callback| when it errors out or it gets response from the worker
+ // calls |callback| when it errors out or it gets a response from the worker
// to notify install completion.
- // |active_version_embedded_worker_id| must be a valid positive ID
- // if there's an active (previous) version running.
+ // |active_version_id| must be a valid positive ID
+ // if there's an activated (previous) version running.
//
// This must be called when the status() is NEW. Calling this changes
// the version's status to INSTALLING.
// Upon completion, the version's status will be changed to INSTALLED
// on success, or back to NEW on failure.
- void DispatchInstallEvent(int active_version_embedded_worker_id,
+ void DispatchInstallEvent(int active_version_id,
const StatusCallback& callback);
// Sends activate event to the associated embedded worker and asynchronously
- // calls |callback| when it errors out or it gets response from the worker
+ // calls |callback| when it errors out or it gets a response from the worker
// to notify activation completion.
//
// This must be called when the status() is INSTALLED. Calling this changes
// the version's status to ACTIVATING.
- // Upon completion, the version's status will be changed to ACTIVE
+ // Upon completion, the version's status will be changed to ACTIVATED
// on success, or back to INSTALLED on failure.
void DispatchActivateEvent(const StatusCallback& callback);
// Sends fetch event to the associated embedded worker and calls
// |callback| with the response from the worker.
//
- // This must be called when the status() is ACTIVE. Calling this in other
+ // This must be called when the status() is ACTIVATED. Calling this in other
// statuses will result in an error SERVICE_WORKER_ERROR_FAILED.
void DispatchFetchEvent(const ServiceWorkerFetchRequest& request,
- const FetchCallback& callback);
+ const base::Closure& prepare_callback,
+ const FetchCallback& fetch_callback);
- // These are expected to be called when a renderer process host for the
- // same-origin as for this ServiceWorkerVersion is created. The added
- // processes are used to run an in-renderer embedded worker.
- void AddProcessToWorker(int process_id);
- void RemoveProcessToWorker(int process_id);
+ // Sends sync event to the associated embedded worker and asynchronously calls
+ // |callback| when it errors out or it gets a response from the worker to
+ // notify completion.
+ //
+ // This must be called when the status() is ACTIVATED.
+ void DispatchSyncEvent(const StatusCallback& callback);
+ // Sends push event to the associated embedded worker and asynchronously calls
+ // |callback| when it errors out or it gets a response from the worker to
+ // notify completion.
+ //
+ // This must be called when the status() is ACTIVATED.
+ void DispatchPushEvent(const StatusCallback& callback,
+ const std::string& data);
+
+ // Sends geofencing event to the associated embedded worker and asynchronously
+ // calls |callback| when it errors out or it gets a response from the worker
+ // to notify completion.
+ //
+ // This must be called when the status() is ACTIVATED.
+ void DispatchGeofencingEvent(
+ const StatusCallback& callback,
+ blink::WebGeofencingEventType event_type,
+ const std::string& region_id,
+ const blink::WebCircularGeofencingRegion& region);
+
+ // Adds and removes |provider_host| as a controllee of this ServiceWorker.
+ // A potential controllee is a host having the version as its .installing
+ // or .waiting version.
+ void AddControllee(ServiceWorkerProviderHost* provider_host);
+ void RemoveControllee(ServiceWorkerProviderHost* provider_host);
+
+ // Returns if it has controllee.
+ bool HasControllee() const { return !controllee_map_.empty(); }
+
+ // Adds and removes Listeners.
+ void AddListener(Listener* listener);
+ void RemoveListener(Listener* listener);
+
+ ServiceWorkerScriptCacheMap* script_cache_map() { return &script_cache_map_; }
EmbeddedWorkerInstance* embedded_worker() { return embedded_worker_.get(); }
- // EmbeddedWorkerInstance::Observer overrides:
- virtual void OnStarted() OVERRIDE;
- virtual void OnStopped() OVERRIDE;
- virtual void OnMessageReceived(int request_id,
- const IPC::Message& message) OVERRIDE;
+ // Dooms this version to have REDUNDANT status and its resources deleted. If
+ // the version is controlling a page, these changes will happen when the
+ // version no longer controls any pages.
+ void Doom();
+ bool is_doomed() const { return is_doomed_; }
private:
- typedef ServiceWorkerVersion self;
friend class base::RefCounted<ServiceWorkerVersion>;
-
- virtual ~ServiceWorkerVersion();
+ FRIEND_TEST_ALL_PREFIXES(ServiceWorkerControlleeRequestHandlerTest,
+ ActivateWaitingVersion);
+ FRIEND_TEST_ALL_PREFIXES(ServiceWorkerVersionTest, ScheduleStopWorker);
+ FRIEND_TEST_ALL_PREFIXES(ServiceWorkerVersionTest, ListenerAvailability);
+ typedef ServiceWorkerVersion self;
+ typedef std::map<ServiceWorkerProviderHost*, int> ControlleeMap;
+ typedef IDMap<ServiceWorkerProviderHost> ControlleeByIDMap;
+
+ ~ServiceWorkerVersion() override;
+
+ // EmbeddedWorkerInstance::Listener overrides:
+ void OnStarted() override;
+ void OnStopped() override;
+ void OnReportException(const base::string16& error_message,
+ int line_number,
+ int column_number,
+ const GURL& source_url) override;
+ void OnReportConsoleMessage(int source_identifier,
+ int message_level,
+ const base::string16& message,
+ int line_number,
+ const GURL& source_url) override;
+ bool OnMessageReceived(const IPC::Message& message) override;
+
+ void OnStartMessageSent(ServiceWorkerStatusCode status);
+
+ void DispatchInstallEventAfterStartWorker(int active_version_id,
+ const StatusCallback& callback);
+ void DispatchActivateEventAfterStartWorker(const StatusCallback& callback);
+
+ // Message handlers.
+ void OnGetClientDocuments(int request_id);
+ void OnActivateEventFinished(int request_id,
+ blink::WebServiceWorkerEventResult result);
+ void OnInstallEventFinished(int request_id,
+ blink::WebServiceWorkerEventResult result);
+ void OnFetchEventFinished(int request_id,
+ ServiceWorkerFetchEventResult result,
+ const ServiceWorkerResponse& response);
+ void OnSyncEventFinished(int request_id);
+ void OnPushEventFinished(int request_id);
+ void OnGeofencingEventFinished(int request_id);
+ void OnPostMessageToDocument(int client_id,
+ const base::string16& message,
+ const std::vector<int>& sent_message_port_ids);
+
+ void ScheduleStopWorker();
+ void DoomInternal();
const int64 version_id_;
-
+ int64 registration_id_;
+ GURL script_url_;
+ GURL scope_;
Status status_;
-
- bool is_shutdown_;
- scoped_refptr<ServiceWorkerRegistration> registration_;
scoped_ptr<EmbeddedWorkerInstance> embedded_worker_;
-
- // Pending callbacks.
+ scoped_ptr<ServiceWorkerCacheListener> cache_listener_;
std::vector<StatusCallback> start_callbacks_;
std::vector<StatusCallback> stop_callbacks_;
-
std::vector<base::Closure> status_change_callbacks_;
- IDMap<MessageCallback, IDMapOwnPointer> message_callbacks_;
+ // Message callbacks.
+ IDMap<StatusCallback, IDMapOwnPointer> activate_callbacks_;
+ IDMap<StatusCallback, IDMapOwnPointer> install_callbacks_;
+ IDMap<FetchCallback, IDMapOwnPointer> fetch_callbacks_;
+ IDMap<StatusCallback, IDMapOwnPointer> sync_callbacks_;
+ IDMap<StatusCallback, IDMapOwnPointer> push_callbacks_;
+ IDMap<StatusCallback, IDMapOwnPointer> geofencing_callbacks_;
+
+ ControlleeMap controllee_map_;
+ ControlleeByIDMap controllee_by_id_;
+ base::WeakPtr<ServiceWorkerContextCore> context_;
+ ObserverList<Listener> listeners_;
+ ServiceWorkerScriptCacheMap script_cache_map_;
+ base::OneShotTimer<ServiceWorkerVersion> stop_worker_timer_;
+ base::OneShotTimer<ServiceWorkerVersion> update_timer_;
+ bool is_doomed_;
base::WeakPtrFactory<ServiceWorkerVersion> weak_factory_;
projects / platform / framework / web / crosswalk.git / blobdiff