Parse manifest file with app.service_worker.script.

extensions/common/manifest_handlers/background_info.cc

 // Copyright 2013 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 "extensions/common/manifest_handlers/background_info.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 45 matching lines @@
 
 // static
 GURL BackgroundInfo::GetBackgroundURL(const Extension* extension) {
   const BackgroundInfo& info = GetBackgroundInfo(extension);
   if (info.background_scripts_.empty())
     return info.background_url_;
   return extension->GetResourceURL(kGeneratedBackgroundPageFilename);
 }
 
 // static
-bool BackgroundInfo::HasGeneratedBackgroundPage(const Extension* extension) {
-  const BackgroundInfo& info = GetBackgroundInfo(extension);
-  return !info.background_scripts_.empty();
-}
-
-// static
 const std::vector<std::string>& BackgroundInfo::GetBackgroundScripts(
     const Extension* extension) {
   return GetBackgroundInfo(extension).background_scripts_;
 }
 
 // static
+std::string BackgroundInfo::GetServiceWorkerScript(const Extension* extension) {
+  return GetBackgroundInfo(extension).service_worker_script_;
+}
+
+// static
 bool BackgroundInfo::HasBackgroundPage(const Extension* extension) {
   return GetBackgroundInfo(extension).has_background_page();
 }
 
 // static
-bool BackgroundInfo::AllowJSAccess(const Extension* extension) {
-  return GetBackgroundInfo(extension).allow_js_access_;
-}
-
-// static
 bool BackgroundInfo::HasPersistentBackgroundPage(const Extension* extension)  {
   return GetBackgroundInfo(extension).has_persistent_background_page();
 }
 
 // static
 bool BackgroundInfo::HasLazyBackgroundPage(const Extension* extension) {
   return GetBackgroundInfo(extension).has_lazy_background_page();
 }
 
+// static
+bool BackgroundInfo::HasGeneratedBackgroundPage(const Extension* extension) {
+  const BackgroundInfo& info = GetBackgroundInfo(extension);
+  return !info.background_scripts_.empty();
+}
+
+// static
+bool BackgroundInfo::HasServiceWorker(const Extension* extension) {
+  return GetBackgroundInfo(extension).has_service_worker();
+}
+
+// static
+bool BackgroundInfo::AllowJSAccess(const Extension* extension) {
+  return GetBackgroundInfo(extension).allow_js_access_;
+}
+
 bool BackgroundInfo::Parse(const Extension* extension, base::string16* error) {
   const std::string& bg_scripts_key = extension->is_platform_app() ?
       keys::kPlatformAppBackgroundScripts : keys::kBackgroundScripts;
-  if (!LoadBackgroundScripts(extension, bg_scripts_key, error) ||
+  const std::string& sw_scripts_key =
+      extension->is_platform_app()
+          ? keys::kPlatformAppServiceWorkerScript
+          : "";  // TODO(scheib): Support extensions crbug.com/346885
+  if (!LoadServiceWorkerScript(extension, sw_scripts_key, error) ||
+      !LoadBackgroundScripts(extension, bg_scripts_key, error) ||
       !LoadBackgroundPage(extension, error) ||
       !LoadBackgroundPersistent(extension, error) ||
       !LoadAllowJSAccess(extension, error)) {
     return false;
   }
   return true;
 }
 
+bool BackgroundInfo::LoadServiceWorkerScript(const Extension* extension,

[Jeffrey Yasskin, 2014/02/28 01:54:37]

The Service Worker is only going to actually work if
chrome://flags/#enable-service-worker is enabled. Actively failing this load
when it's disabled will make unittesting hard, but I wonder if there's some way
we can remind people who try this that they need to flip a flag?

[Yoyo Zhou, 2014/02/28 17:59:09]

Set *error to a relevant message.

By the way, you should be able to set flags in unittests' SetUp. This all seems
fine.

[scheib, 2014/03/03 19:54:00]

Done.

+                                             const std::string& key,
+                                             base::string16* error) {
+  const base::Value* service_worker_script_value = NULL;
+  if (!extension->manifest()->Get(key, &service_worker_script_value))
+    return true;
+
+  CHECK(service_worker_script_value);
+  if (!service_worker_script_value->GetAsString(&service_worker_script_)) {
+    *error = ASCIIToUTF16(errors::kInvalidServiceWorkerScript);
+    return false;
+  }
+  return true;
+}
+
 bool BackgroundInfo::LoadBackgroundScripts(const Extension* extension,
                                            const std::string& key,
                                            base::string16* error) {
   const base::Value* background_scripts_value = NULL;
   if (!extension->manifest()->Get(key, &background_scripts_value))
     return true;
 
+  if (has_service_worker()) {

[Jeffrey Yasskin, 2014/02/28 01:54:37]

Could you put this in BgInfo::Parse so that its correctness doesn't depend on
the order in which Parse() calls its helper functions?

[scheib, 2014/03/03 19:54:00]

Done.

+    *error = ASCIIToUTF16(errors::kInvalidBackgroundCombination);
+    return false;
+  }
+
   CHECK(background_scripts_value);
   if (background_scripts_value->GetType() != base::Value::TYPE_LIST) {
     *error = ASCIIToUTF16(errors::kInvalidBackgroundScripts);
     return false;
   }
 
   const base::ListValue* background_scripts = NULL;
   background_scripts_value->GetAsList(&background_scripts);
   for (size_t i = 0; i < background_scripts->GetSize(); ++i) {
     std::string script;
     if (!background_scripts->GetString(i, &script)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidBackgroundScript, base::IntToString(i));
       return false;
     }
     background_scripts_.push_back(script);
   }
 
   return true;
 }
 
 bool BackgroundInfo::LoadBackgroundPage(const Extension* extension,
                                         const std::string& key,
                                         base::string16* error) {
   const base::Value* background_page_value = NULL;
   if (!extension->manifest()->Get(key, &background_page_value))
     return true;
 
-  if (!background_scripts_.empty()) {
+  if (!background_scripts_.empty() || has_service_worker()) {
     *error = ASCIIToUTF16(errors::kInvalidBackgroundCombination);
     return false;
   }
 
   std::string background_str;
   if (!background_page_value->GetAsString(&background_str)) {
     *error = ASCIIToUTF16(errors::kInvalidBackground);
     return false;
   }
 
@@ skipping 85 matching lines @@
 
 BackgroundManifestHandler::~BackgroundManifestHandler() {
 }
 
 bool BackgroundManifestHandler::Parse(Extension* extension,
                                       base::string16* error) {
   scoped_ptr<BackgroundInfo> info(new BackgroundInfo);
   if (!info->Parse(extension, error))
     return false;
 
-  // Platform apps must have background pages.
-  if (extension->is_platform_app() && !info->has_background_page()) {
+  // Platform apps must have background pages or service workers.
+  if (extension->is_platform_app() && !info->has_background_page() &&
+      !info->has_service_worker()) {
     *error = ASCIIToUTF16(errors::kBackgroundRequiredForPlatformApps);
     return false;
   }
   // Lazy background pages are incompatible with the webRequest API.
   if (info->has_lazy_background_page() &&
       PermissionsData::GetInitialAPIPermissions(extension)->count(
           APIPermission::kWebRequest)) {
     *error = ASCIIToUTF16(errors::kWebRequestConflictsWithLazyBackground);
     return false;
   }
@@ skipping 43 matching lines @@
 }
 
 const std::vector<std::string> BackgroundManifestHandler::Keys() const {
   static const char* keys[] = {
     keys::kBackgroundAllowJsAccess,
     keys::kBackgroundPage,
     keys::kBackgroundPageLegacy,
     keys::kBackgroundPersistent,
     keys::kBackgroundScripts,
     keys::kPlatformAppBackgroundPage,
     keys::kPlatformAppBackgroundScripts

[not at google - send to devlin, 2014/02/28 17:48:14]

(partly as a response to Jeffrey's comment) I would expect to see a service
worker related key down here, but all the existing keys currently deal with a
"background" key (either top-level or within "app").

It's a response to Jeffrey because that indicates to me this isn't the right
place to do the manifest parsing. But I also could be wrong :)

[Yoyo Zhou, 2014/02/28 17:59:09]

This is the list of keys which, if any is present, causes this ManifestHandler
to Parse at all. It's like a pre-check on whether to make the ManifestHandler do
any work. So yes, you do need to put the service worker keys in here.

(Your tests are able to pass because of AlwaysParseForType returning true
anyway; I don't recall the exact bug that that fixed.)

[scheib, 2014/03/03 19:54:00]

Done.

   };
   return std::vector<std::string>(keys, keys + arraysize(keys));
 }
 
 }  // namespace extensions