AppCacheExecutableHandlers - parse manifest file and store the 'bit' indicating executable.

webkit/appcache/appcache_interfaces.cc

 // Copyright (c) 2012 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 "webkit/appcache/appcache_interfaces.h"
 
 #include <set>
 
 #include "base/lazy_instance.h"
 #include "base/string_util.h"
@@ skipping 12 matching lines @@
 
 }  // namespace
 
 namespace appcache {
 
 const char kHttpScheme[] = "http";
 const char kHttpsScheme[] = "https";
 const char kHttpGETMethod[] = "GET";
 const char kHttpHEADMethod[] = "HEAD";
 
+const char kEnableExecutableHandlers[] = "enable-appcache-executable-handlers";
+
 const base::FilePath::CharType kAppCacheDatabaseName[] =
     FILE_PATH_LITERAL("Index");
 
 AppCacheInfo::AppCacheInfo()
     : cache_id(kNoCacheId),
       group_id(0),
       status(UNCACHED),
       size(0),
       is_complete(false) {
 }
@@ skipping 11 matching lines @@
       is_foreign(false),
       is_explicit(false),
       response_id(kNoResponseId) {
 }
 
 AppCacheResourceInfo::~AppCacheResourceInfo() {
 }
 
 Namespace::Namespace()
     : type(FALLBACK_NAMESPACE),
-      is_pattern(false) {
+      is_pattern(false),
+      is_executable(false) {
 }
 
 Namespace::Namespace(
     NamespaceType type, const GURL& url, const GURL& target, bool is_pattern)
     : type(type),
       namespace_url(url),
       target_url(target),
-      is_pattern(is_pattern) {
+      is_pattern(is_pattern),
+      is_executable(false) {

[alecflett, 2013/04/16 22:28:56]

Seems like its worth keeping a single constructor around for explicitly
requiring is_executable = false

[michaeln, 2013/04/16 22:43:02]

thought about it, certainly if/when we decide to keep this exp in the code base
for the long haul would want to do that, but i expect we'll yank it at some
point so didn't do that to make it easier to yank

i could just not have the extra ctor at all and alter the callsite(s) to set the
member after construction

+}
+
+Namespace::Namespace(
+    NamespaceType type, const GURL& url, const GURL& target,
+    bool is_pattern, bool is_executable)
+    : type(type),
+      namespace_url(url),
+      target_url(target),
+      is_pattern(is_pattern),
+      is_executable(is_executable) {
 }
 
 Namespace::~Namespace() {
 }
 
 bool Namespace::IsMatch(const GURL& url) const {
   if (is_pattern) {
     // We have to escape '?' characters since MatchPattern also treats those
     // as wildcards which we don't want here, we only do '*'s.
     std::string pattern = namespace_url.spec();
@@ skipping 68 matching lines @@
 COMPILE_ASSERT((int)WebConsoleMessage::LevelDebug ==
                (int)LOG_DEBUG, LevelDebug);
 COMPILE_ASSERT((int)WebConsoleMessage::LevelLog ==
                (int)LOG_INFO, LevelLog);
 COMPILE_ASSERT((int)WebConsoleMessage::LevelWarning ==
                (int)LOG_WARNING, LevelWarning);
 COMPILE_ASSERT((int)WebConsoleMessage::LevelError ==
                (int)LOG_ERROR, LevelError);
 
 }  // namespace appcache