[jumbo] move some service worker consts to a struct to avoid collisions

Bug: 746953
Change-Id: I4de7e03f07fa19b0d7c136f2ca6021c8dd8cdd3d

TBR=dpranke@chromium.org

Change-Id: I4de7e03f07fa19b0d7c136f2ca6021c8dd8cdd3d
Reviewed-on: https://chromium-review.googlesource.com/755717
Commit-Queue: Mostyn Bramley-Moore <mostynb@vewd.com>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Reviewed-by: Bruce Dawson <brucedawson@chromium.org>
Cr-Commit-Position: refs/heads/master@{#515038}

content/browser/BUILD.gn

@@ -1452,6 +1452,8 @@ source_set("browser") {
     "service_worker/service_worker_cache_writer.h",
     "service_worker/service_worker_client_utils.cc",
     "service_worker/service_worker_client_utils.h",
+    "service_worker/service_worker_consts.cc",
+    "service_worker/service_worker_consts.h",
     "service_worker/service_worker_content_settings_proxy_impl.cc",
     "service_worker/service_worker_content_settings_proxy_impl.h",
     "service_worker/service_worker_context_core.cc",

content/browser/service_worker/service_worker_consts.cc

+// Copyright 2017 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_consts.h"
+
+namespace content {
+
+const char ServiceWorkerConsts::kBadMessageFromNonWindow[] =
+    "The request message should not come from a non-window client.";
+
+const char ServiceWorkerConsts::kBadMessageGetRegistrationForReadyDuplicated[] =
+    "There's already a completed or ongoing request to get the ready "
+    "registration.";
+
+const char ServiceWorkerConsts::kBadMessageImproperOrigins[] =
+    "Origins are not matching, or some cannot access service worker.";
+
+const char ServiceWorkerConsts::kBadMessageInvalidURL[] =
+    "Some URLs are invalid.";
+
+const char ServiceWorkerConsts::kBadNavigationPreloadHeaderValue[] =
+    "The navigation preload header value is invalid.";
+
+const char ServiceWorkerConsts::kDatabaseErrorMessage[] =
+    "Failed to access storage.";
+
+const char ServiceWorkerConsts::kEnableNavigationPreloadErrorPrefix[] =
+    "Failed to enable or disable navigation preload: ";
+
+const char ServiceWorkerConsts::kGetNavigationPreloadStateErrorPrefix[] =
+    "Failed to get navigation preload state: ";
+
+const char ServiceWorkerConsts::kInvalidStateErrorMessage[] =
+    "The object is in an invalid state.";
+
+const char ServiceWorkerConsts::kNoActiveWorkerErrorMessage[] =
+    "The registration does not have an active worker.";
+
+const char ServiceWorkerConsts::kNoDocumentURLErrorMessage[] =
+    "No URL is associated with the caller's document.";
+
+const char ServiceWorkerConsts::kSetNavigationPreloadHeaderErrorPrefix[] =
+    "Failed to set navigation preload header: ";
+
+const char ServiceWorkerConsts::kShutdownErrorMessage[] =
+    "The Service Worker system has shutdown.";
+
+const char ServiceWorkerConsts::kUserDeniedPermissionMessage[] =
+    "The user denied permission to use Service Worker.";
+
+}  // namespace content

content/browser/service_worker/service_worker_consts.h

+// Copyright 2017 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_CONSTS_H_
+#define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONSTS_H_
+
+namespace content {
+
+struct ServiceWorkerConsts {
+  static const char kBadMessageFromNonWindow[];
+  static const char kBadMessageGetRegistrationForReadyDuplicated[];
+  static const char kBadMessageImproperOrigins[];
+  static const char kBadMessageInvalidURL[];
+  static const char kBadNavigationPreloadHeaderValue[];
+  static const char kDatabaseErrorMessage[];
+  static const char kEnableNavigationPreloadErrorPrefix[];
+  static const char kGetNavigationPreloadStateErrorPrefix[];
+  static const char kInvalidStateErrorMessage[];
+  static const char kNoActiveWorkerErrorMessage[];
+  static const char kNoDocumentURLErrorMessage[];
+  static const char kSetNavigationPreloadHeaderErrorPrefix[];
+  static const char kShutdownErrorMessage[];
+  static const char kUserDeniedPermissionMessage[];
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONSTS_H_

content/browser/service_worker/service_worker_provider_host.cc

@@ -15,6 +15,7 @@
 #include "content/browser/bad_message.h"
 #include "content/browser/interface_provider_filtering.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
+#include "content/browser/service_worker/service_worker_consts.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_request_handler.h"
 #include "content/browser/service_worker/service_worker_controllee_request_handler.h"
@@ -48,21 +49,6 @@ namespace content {
 
 namespace {
 
-const char kNoDocumentURLErrorMessage[] =
-    "No URL is associated with the caller's document.";
-const char kShutdownErrorMessage[] = "The Service Worker system has shutdown.";
-const char kUserDeniedPermissionMessage[] =
-    "The user denied permission to use Service Worker.";
-
-const char kBadMessageInvalidURL[] = "Some URLs are invalid.";
-const char kBadMessageInproperOrigins[] =
-    "Origins are not matching, or some cannot access service worker.";
-const char kBadMessageFromNonWindow[] =
-    "The request message should not come from a non-window client.";
-const char kBadMessageGetRegistrationForReadyDuplicated[] =
-    "There's already a completed or ongoing request to get the ready "
-    "registration.";
-
 // Provider host for navigation with PlzNavigate or when service worker's
 // context is created on the browser side. This function provides the next
 // ServiceWorkerProviderHost ID for them, starts at -2 and keeps going down.
@@ -928,10 +914,11 @@ void ServiceWorkerProviderHost::RegistrationComplete(
                          trace_id, "Status", status, "Registration ID",
                          registration_id);
   if (!dispatcher_host_ || !IsContextAlive()) {
-    std::move(callback).Run(blink::mojom::ServiceWorkerErrorType::kAbort,
-                            std::string(kServiceWorkerRegisterErrorPrefix) +
-                                std::string(kShutdownErrorMessage),
-                            nullptr);
+    std::move(callback).Run(
+        blink::mojom::ServiceWorkerErrorType::kAbort,
+        std::string(kServiceWorkerRegisterErrorPrefix) +
+            std::string(ServiceWorkerConsts::kShutdownErrorMessage),
+        nullptr);
     return;
   }
 
@@ -1027,7 +1014,7 @@ void ServiceWorkerProviderHost::GetRegistrationComplete(
     std::move(callback).Run(
         blink::mojom::ServiceWorkerErrorType::kAbort,
         std::string(kServiceWorkerGetRegistrationErrorPrefix) +
-            std::string(kShutdownErrorMessage),
+            std::string(ServiceWorkerConsts::kShutdownErrorMessage),
         nullptr);
     return;
   }
@@ -1065,7 +1052,7 @@ void ServiceWorkerProviderHost::GetRegistrationsComplete(
     std::move(callback).Run(
         blink::mojom::ServiceWorkerErrorType::kAbort,
         std::string(kServiceWorkerGetRegistrationsErrorPrefix) +
-            std::string(kShutdownErrorMessage),
+            std::string(ServiceWorkerConsts::kShutdownErrorMessage),
         base::nullopt);
     return;
   }
@@ -1142,11 +1129,11 @@ bool ServiceWorkerProviderHost::IsValidRegisterMessage(
     const blink::mojom::ServiceWorkerRegistrationOptions& options,
     std::string* out_error) const {
   if (client_type() != blink::kWebServiceWorkerClientTypeWindow) {
-    *out_error = kBadMessageFromNonWindow;
+    *out_error = ServiceWorkerConsts::kBadMessageFromNonWindow;
     return false;
   }
   if (!options.scope.is_valid() || !script_url.is_valid()) {
-    *out_error = kBadMessageInvalidURL;
+    *out_error = ServiceWorkerConsts::kBadMessageInvalidURL;
     return false;
   }
   if (ServiceWorkerUtils::ContainsDisallowedCharacter(options.scope, script_url,
@@ -1155,7 +1142,7 @@ bool ServiceWorkerProviderHost::IsValidRegisterMessage(
   }
   std::vector<GURL> urls = {document_url(), options.scope, script_url};
   if (!ServiceWorkerUtils::AllOriginsMatchAndCanAccessServiceWorkers(urls)) {
-    *out_error = kBadMessageInproperOrigins;
+    *out_error = ServiceWorkerConsts::kBadMessageImproperOrigins;
     return false;
   }
 
@@ -1166,16 +1153,16 @@ bool ServiceWorkerProviderHost::IsValidGetRegistrationMessage(
     const GURL& client_url,
     std::string* out_error) const {
   if (client_type() != blink::kWebServiceWorkerClientTypeWindow) {
-    *out_error = kBadMessageFromNonWindow;
+    *out_error = ServiceWorkerConsts::kBadMessageFromNonWindow;
     return false;
   }
   if (!client_url.is_valid()) {
-    *out_error = kBadMessageInvalidURL;
+    *out_error = ServiceWorkerConsts::kBadMessageInvalidURL;
     return false;
   }
   std::vector<GURL> urls = {document_url(), client_url};
   if (!ServiceWorkerUtils::AllOriginsMatchAndCanAccessServiceWorkers(urls)) {
-    *out_error = kBadMessageInproperOrigins;
+    *out_error = ServiceWorkerConsts::kBadMessageImproperOrigins;
     return false;
   }
 
@@ -1185,11 +1172,11 @@ bool ServiceWorkerProviderHost::IsValidGetRegistrationMessage(
 bool ServiceWorkerProviderHost::IsValidGetRegistrationsMessage(
     std::string* out_error) const {
   if (client_type() != blink::kWebServiceWorkerClientTypeWindow) {
-    *out_error = kBadMessageFromNonWindow;
+    *out_error = ServiceWorkerConsts::kBadMessageFromNonWindow;
     return false;
   }
   if (!OriginCanAccessServiceWorkers(document_url())) {
-    *out_error = kBadMessageInproperOrigins;
+    *out_error = ServiceWorkerConsts::kBadMessageImproperOrigins;
     return false;
   }
 
@@ -1199,12 +1186,13 @@ bool ServiceWorkerProviderHost::IsValidGetRegistrationsMessage(
 bool ServiceWorkerProviderHost::IsValidGetRegistrationForReadyMessage(
     std::string* out_error) const {
   if (client_type() != blink::kWebServiceWorkerClientTypeWindow) {
-    *out_error = kBadMessageFromNonWindow;
+    *out_error = ServiceWorkerConsts::kBadMessageFromNonWindow;
     return false;
   }
 
   if (get_ready_callback_) {
-    *out_error = kBadMessageGetRegistrationForReadyDuplicated;
+    *out_error =
+        ServiceWorkerConsts::kBadMessageGetRegistrationForReadyDuplicated;
     return false;
   }
 
@@ -1233,7 +1221,8 @@ bool ServiceWorkerProviderHost::CanServeContainerHostMethods(
   if (!dispatcher_host_ || !IsContextAlive()) {
     std::move(*callback).Run(
         blink::mojom::ServiceWorkerErrorType::kAbort,
-        std::string(error_prefix) + std::string(kShutdownErrorMessage),
+        std::string(error_prefix) +
+            std::string(ServiceWorkerConsts::kShutdownErrorMessage),
         args...);
     return false;
   }
@@ -1243,7 +1232,8 @@ bool ServiceWorkerProviderHost::CanServeContainerHostMethods(
   if (document_url().is_empty()) {
     std::move(*callback).Run(
         blink::mojom::ServiceWorkerErrorType::kSecurity,
-        std::string(error_prefix) + std::string(kNoDocumentURLErrorMessage),
+        std::string(error_prefix) +
+            std::string(ServiceWorkerConsts::kNoDocumentURLErrorMessage),
         args...);
     return false;
   }
@@ -1253,7 +1243,8 @@ bool ServiceWorkerProviderHost::CanServeContainerHostMethods(
           base::Bind(&GetWebContents, render_process_id_, frame_id()))) {
     std::move(*callback).Run(
         blink::mojom::ServiceWorkerErrorType::kDisabled,
-        std::string(error_prefix) + std::string(kUserDeniedPermissionMessage),
+        std::string(error_prefix) +
+            std::string(ServiceWorkerConsts::kUserDeniedPermissionMessage),
         args...);
     return false;
   }

content/browser/service_worker/service_worker_registration_handle.cc

@@ -4,6 +4,7 @@
 
 #include "content/browser/service_worker/service_worker_registration_handle.h"
 
+#include "content/browser/service_worker/service_worker_consts.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_dispatcher_host.h"
 #include "content/browser/service_worker/service_worker_handle.h"
@@ -23,26 +24,6 @@ namespace content {
 
 namespace {
 
-const char kNoDocumentURLErrorMessage[] =
-    "No URL is associated with the caller's document.";
-const char kShutdownErrorMessage[] = "The Service Worker system has shutdown.";
-const char kUserDeniedPermissionMessage[] =
-    "The user denied permission to use Service Worker.";
-const char kEnableNavigationPreloadErrorPrefix[] =
-    "Failed to enable or disable navigation preload: ";
-const char kGetNavigationPreloadStateErrorPrefix[] =
-    "Failed to get navigation preload state: ";
-const char kSetNavigationPreloadHeaderErrorPrefix[] =
-    "Failed to set navigation preload header: ";
-const char kInvalidStateErrorMessage[] = "The object is in an invalid state.";
-const char kBadMessageImproperOrigins[] =
-    "Origins are not matching, or some cannot access service worker.";
-const char kBadNavigationPreloadHeaderValue[] =
-    "The navigation preload header value is invalid.";
-const char kNoActiveWorkerErrorMessage[] =
-    "The registration does not have an active worker.";
-const char kDatabaseErrorMessage[] = "Failed to access storage.";
-
 WebContents* GetWebContents(int render_process_id, int render_frame_id) {
   RenderFrameHost* rfh =
       RenderFrameHost::FromID(render_process_id, render_frame_id);
@@ -137,9 +118,10 @@ void ServiceWorkerRegistrationHandle::Update(UpdateCallback callback) {
   if (!registration_->GetNewestVersion()) {
     // This can happen if update() is called during initial script evaluation.
     // Abort the following steps according to the spec.
-    std::move(callback).Run(blink::mojom::ServiceWorkerErrorType::kState,
-                            std::string(kServiceWorkerUpdateErrorPrefix) +
-                                std::string(kInvalidStateErrorMessage));
+    std::move(callback).Run(
+        blink::mojom::ServiceWorkerErrorType::kState,
+        std::string(kServiceWorkerUpdateErrorPrefix) +
+            std::string(ServiceWorkerConsts::kInvalidStateErrorMessage));
     return;
   }
 
@@ -168,14 +150,16 @@ void ServiceWorkerRegistrationHandle::EnableNavigationPreload(
     bool enable,
     EnableNavigationPreloadCallback callback) {
   if (!CanServeRegistrationObjectHostMethods(
-          &callback, kEnableNavigationPreloadErrorPrefix)) {
+          &callback,
+          ServiceWorkerConsts::kEnableNavigationPreloadErrorPrefix)) {
     return;
   }
 
   if (!registration_->active_version()) {
-    std::move(callback).Run(blink::mojom::ServiceWorkerErrorType::kState,
-                            std::string(kEnableNavigationPreloadErrorPrefix) +
-                                std::string(kNoActiveWorkerErrorMessage));
+    std::move(callback).Run(
+        blink::mojom::ServiceWorkerErrorType::kState,
+        std::string(ServiceWorkerConsts::kEnableNavigationPreloadErrorPrefix) +
+            std::string(ServiceWorkerConsts::kNoActiveWorkerErrorMessage));
     return;
   }
 
@@ -189,7 +173,8 @@ void ServiceWorkerRegistrationHandle::EnableNavigationPreload(
 void ServiceWorkerRegistrationHandle::GetNavigationPreloadState(
     GetNavigationPreloadStateCallback callback) {
   if (!CanServeRegistrationObjectHostMethods(
-          &callback, kGetNavigationPreloadStateErrorPrefix, nullptr)) {
+          &callback, ServiceWorkerConsts::kGetNavigationPreloadStateErrorPrefix,
+          nullptr)) {
     return;
   }
 
@@ -202,22 +187,25 @@ void ServiceWorkerRegistrationHandle::SetNavigationPreloadHeader(
     const std::string& value,
     SetNavigationPreloadHeaderCallback callback) {
   if (!CanServeRegistrationObjectHostMethods(
-          &callback, kSetNavigationPreloadHeaderErrorPrefix)) {
+          &callback,
+          ServiceWorkerConsts::kSetNavigationPreloadHeaderErrorPrefix)) {
     return;
   }
 
   if (!registration_->active_version()) {
     std::move(callback).Run(
         blink::mojom::ServiceWorkerErrorType::kState,
-        std::string(kSetNavigationPreloadHeaderErrorPrefix) +
-            std::string(kNoActiveWorkerErrorMessage));
+        std::string(
+            ServiceWorkerConsts::kSetNavigationPreloadHeaderErrorPrefix) +
+            std::string(ServiceWorkerConsts::kNoActiveWorkerErrorMessage));
     return;
   }
 
   // TODO(falken): Ideally this would match Blink's isValidHTTPHeaderValue.
   // Chrome's check is less restrictive: it allows non-latin1 characters.
   if (!net::HttpUtil::IsValidHeaderValue(value)) {
-    bindings_.ReportBadMessage(kBadNavigationPreloadHeaderValue);
+    bindings_.ReportBadMessage(
+        ServiceWorkerConsts::kBadNavigationPreloadHeaderValue);
     return;
   }
 
@@ -269,9 +257,10 @@ void ServiceWorkerRegistrationHandle::DidUpdateNavigationPreloadEnabled(
     EnableNavigationPreloadCallback callback,
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK) {
-    std::move(callback).Run(blink::mojom::ServiceWorkerErrorType::kUnknown,
-                            std::string(kEnableNavigationPreloadErrorPrefix) +
-                                std::string(kDatabaseErrorMessage));
+    std::move(callback).Run(
+        blink::mojom::ServiceWorkerErrorType::kUnknown,
+        std::string(ServiceWorkerConsts::kEnableNavigationPreloadErrorPrefix) +
+            std::string(ServiceWorkerConsts::kDatabaseErrorMessage));
     return;
   }
 
@@ -288,8 +277,9 @@ void ServiceWorkerRegistrationHandle::DidUpdateNavigationPreloadHeader(
   if (status != SERVICE_WORKER_OK) {
     std::move(callback).Run(
         blink::mojom::ServiceWorkerErrorType::kUnknown,
-        std::string(kSetNavigationPreloadHeaderErrorPrefix) +
-            std::string(kDatabaseErrorMessage));
+        std::string(
+            ServiceWorkerConsts::kSetNavigationPreloadHeaderErrorPrefix) +
+            std::string(ServiceWorkerConsts::kDatabaseErrorMessage));
     return;
   }
 
@@ -342,7 +332,8 @@ bool ServiceWorkerRegistrationHandle::CanServeRegistrationObjectHostMethods(
   if (!provider_host_ || !context_) {
     std::move(*callback).Run(
         blink::mojom::ServiceWorkerErrorType::kAbort,
-        std::string(error_prefix) + std::string(kShutdownErrorMessage),
+        std::string(error_prefix) +
+            std::string(ServiceWorkerConsts::kShutdownErrorMessage),
         args...);
     return false;
   }
@@ -352,7 +343,8 @@ bool ServiceWorkerRegistrationHandle::CanServeRegistrationObjectHostMethods(
   if (provider_host_->document_url().is_empty()) {
     std::move(*callback).Run(
         blink::mojom::ServiceWorkerErrorType::kSecurity,
-        std::string(error_prefix) + std::string(kNoDocumentURLErrorMessage),
+        std::string(error_prefix) +
+            std::string(ServiceWorkerConsts::kNoDocumentURLErrorMessage),
         args...);
     return false;
   }
@@ -360,7 +352,7 @@ bool ServiceWorkerRegistrationHandle::CanServeRegistrationObjectHostMethods(
   std::vector<GURL> urls = {provider_host_->document_url(),
                             registration_->pattern()};
   if (!ServiceWorkerUtils::AllOriginsMatchAndCanAccessServiceWorkers(urls)) {
-    bindings_.ReportBadMessage(kBadMessageImproperOrigins);
+    bindings_.ReportBadMessage(ServiceWorkerConsts::kBadMessageImproperOrigins);
     return false;
   }
 
@@ -371,7 +363,8 @@ bool ServiceWorkerRegistrationHandle::CanServeRegistrationObjectHostMethods(
                      provider_host_->frame_id()))) {
     std::move(*callback).Run(
         blink::mojom::ServiceWorkerErrorType::kDisabled,
-        std::string(error_prefix) + std::string(kUserDeniedPermissionMessage),
+        std::string(error_prefix) +
+            std::string(ServiceWorkerConsts::kUserDeniedPermissionMessage),
         args...);
     return false;
   }