Report error messages to DevTools window.

content/browser/service_worker/service_worker_context_watcher.cc

 // Copyright 2015 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.
 
 #include "content/browser/service_worker/service_worker_context_watcher.h"
 
 #include "base/bind.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_version.h"
+#include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
 namespace content {
 namespace {
 
 bool IsStoppedAndRedundant(const ServiceWorkerVersionInfo& version_info) {
   return version_info.running_status ==
              content::ServiceWorkerVersion::STOPPED &&
          version_info.status == content::ServiceWorkerVersion::REDUNDANT;
 }
 
 }  // namespace
 
 ServiceWorkerContextWatcher::ServiceWorkerContextWatcher(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     const WorkerRegistrationUpdatedCallback& registration_callback,
-    const WorkerVersionUpdatedCallback& version_callback)
+    const WorkerVersionUpdatedCallback& version_callback,
+    const WorkerErrorReportedCallback& error_callback)
     : context_(context),
       registration_callback_(registration_callback),
-      version_callback_(version_callback) {
+      version_callback_(version_callback),
+      error_callback_(error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 void ServiceWorkerContextWatcher::Start() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ServiceWorkerContextWatcher::GetStoredRegistrationsOnIOThread,
                  this));
 }
@@ skipping 145 matching lines @@
   ServiceWorkerVersionInfo* version = version_info_map_.get(version_id);
   DCHECK(version);
   if (version->status == status)
     return;
   version->status = status;
   SendVersionInfo(*version);
   if (IsStoppedAndRedundant(*version))
     version_info_map_.erase(version_id);
 }
 
+void ServiceWorkerContextWatcher::OnErrorReported(int64 version_id,
+                                                  int process_id,
+                                                  int thread_id,
+                                                  const ErrorInfo& info) {
+  int64 registration_id = kInvalidServiceWorkerRegistrationId;
+  if (ServiceWorkerVersionInfo* version = version_info_map_.get(version_id))
+    registration_id = version->registration_id;
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(error_callback_, registration_id, version_id, info));
+}
+
 void ServiceWorkerContextWatcher::OnRegistrationStored(int64 registration_id,
                                                        const GURL& pattern) {
   SendRegistrationInfo(registration_id, pattern,
                        ServiceWorkerRegistrationInfo::IS_NOT_DELETED);
 }
 
 void ServiceWorkerContextWatcher::OnRegistrationDeleted(int64 registration_id,
                                                         const GURL& pattern) {
   SendRegistrationInfo(registration_id, pattern,
                        ServiceWorkerRegistrationInfo::IS_DELETED);
 }
 
 }  // namespace content