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