1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/browser/service_worker/service_worker_handle.h"
6
7#include "content/browser/service_worker/service_worker_context_core.h"
8#include "content/browser/service_worker/service_worker_registration.h"
9#include "content/common/service_worker/service_worker_messages.h"
10#include "ipc/ipc_sender.h"
11
12namespace content {
13
14namespace {
15
16blink::WebServiceWorkerState
17GetWebServiceWorkerState(ServiceWorkerVersion* version) {
18  DCHECK(version);
19  switch (version->status()) {
20    case ServiceWorkerVersion::NEW:
21      if (version->running_status() == ServiceWorkerVersion::RUNNING)
22        return blink::WebServiceWorkerStateParsed;
23      else
24        return blink::WebServiceWorkerStateUnknown;
25    case ServiceWorkerVersion::INSTALLING:
26      return blink::WebServiceWorkerStateInstalling;
27    case ServiceWorkerVersion::INSTALLED:
28      return blink::WebServiceWorkerStateInstalled;
29    case ServiceWorkerVersion::ACTIVATING:
30      return blink::WebServiceWorkerStateActivating;
31    case ServiceWorkerVersion::ACTIVATED:
32      return blink::WebServiceWorkerStateActivated;
33    case ServiceWorkerVersion::REDUNDANT:
34      return blink::WebServiceWorkerStateRedundant;
35  }
36  NOTREACHED() << version->status();
37  return blink::WebServiceWorkerStateUnknown;
38}
39
40}  // namespace
41
42scoped_ptr<ServiceWorkerHandle> ServiceWorkerHandle::Create(
43    base::WeakPtr<ServiceWorkerContextCore> context,
44    IPC::Sender* sender,
45    int thread_id,
46    int provider_id,
47    ServiceWorkerVersion* version) {
48  if (!context || !version)
49    return scoped_ptr<ServiceWorkerHandle>();
50  ServiceWorkerRegistration* registration =
51      context->GetLiveRegistration(version->registration_id());
52  return make_scoped_ptr(new ServiceWorkerHandle(
53      context, sender, thread_id, provider_id, registration, version));
54}
55
56ServiceWorkerHandle::ServiceWorkerHandle(
57    base::WeakPtr<ServiceWorkerContextCore> context,
58    IPC::Sender* sender,
59    int thread_id,
60    int provider_id,
61    ServiceWorkerRegistration* registration,
62    ServiceWorkerVersion* version)
63    : context_(context),
64      sender_(sender),
65      thread_id_(thread_id),
66      provider_id_(provider_id),
67      handle_id_(context.get() ? context->GetNewServiceWorkerHandleId() : -1),
68      ref_count_(1),
69      registration_(registration),
70      version_(version) {
71  version_->AddListener(this);
72}
73
74ServiceWorkerHandle::~ServiceWorkerHandle() {
75  version_->RemoveListener(this);
76  // TODO(kinuko): At this point we can discard the registration if
77  // all documents/handles that have a reference to the registration is
78  // closed or freed up, but could also keep it alive in cache
79  // (e.g. in context_) for a while with some timer so that we don't
80  // need to re-load the same registration from disk over and over.
81}
82
83void ServiceWorkerHandle::OnWorkerStarted(ServiceWorkerVersion* version) {
84}
85
86void ServiceWorkerHandle::OnWorkerStopped(ServiceWorkerVersion* version) {
87}
88
89void ServiceWorkerHandle::OnErrorReported(ServiceWorkerVersion* version,
90                                          const base::string16& error_message,
91                                          int line_number,
92                                          int column_number,
93                                          const GURL& source_url) {
94}
95
96void ServiceWorkerHandle::OnReportConsoleMessage(ServiceWorkerVersion* version,
97                                                 int source_identifier,
98                                                 int message_level,
99                                                 const base::string16& message,
100                                                 int line_number,
101                                                 const GURL& source_url) {
102}
103
104void ServiceWorkerHandle::OnVersionStateChanged(ServiceWorkerVersion* version) {
105  sender_->Send(new ServiceWorkerMsg_ServiceWorkerStateChanged(
106      thread_id_, handle_id_, GetWebServiceWorkerState(version)));
107}
108
109ServiceWorkerObjectInfo ServiceWorkerHandle::GetObjectInfo() {
110  ServiceWorkerObjectInfo info;
111  info.handle_id = handle_id_;
112  info.scope = registration_->pattern();
113  info.url = version_->script_url();
114  info.state = GetWebServiceWorkerState(version_.get());
115  return info;
116}
117
118void ServiceWorkerHandle::IncrementRefCount() {
119  DCHECK_GT(ref_count_, 0);
120  ++ref_count_;
121}
122
123void ServiceWorkerHandle::DecrementRefCount() {
124  DCHECK_GE(ref_count_, 0);
125  --ref_count_;
126}
127
128}  // namespace content
129