src/webkit/common/appcache/appcache_interfaces.cc

   1 // Copyright (c) 2012 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 "webkit/common/appcache/appcache_interfaces.h"
   6
   7 #include <set>
   8
   9 #include "base/strings/string_util.h"
  10 #include "net/url_request/url_request.h"
  11 #include "url/gurl.h"
  12
  13 namespace appcache {
  14
  15 const char kHttpScheme[] = "http";
  16 const char kHttpsScheme[] = "https";
  17 const char kDevToolsScheme[] = "chrome-devtools";
  18 const char kHttpGETMethod[] = "GET";
  19 const char kHttpHEADMethod[] = "HEAD";
  20
  21 const char kEnableExecutableHandlers[] = "enable-appcache-executable-handlers";
  22
  23 const base::FilePath::CharType kAppCacheDatabaseName[] =
  24     FILE_PATH_LITERAL("Index");
  25
  26 AppCacheInfo::AppCacheInfo()
  27     : cache_id(kNoCacheId),
  28       group_id(0),
  29       status(UNCACHED),
  30       size(0),
  31       is_complete(false) {
  32 }
  33
  34 AppCacheInfo::~AppCacheInfo() {
  35 }
  36
  37 AppCacheResourceInfo::AppCacheResourceInfo()
  38     : url(),
  39       size(0),
  40       is_master(false),
  41       is_manifest(false),
  42       is_intercept(false),
  43       is_fallback(false),
  44       is_foreign(false),
  45       is_explicit(false),
  46       response_id(kNoResponseId) {
  47 }
  48
  49 AppCacheResourceInfo::~AppCacheResourceInfo() {
  50 }
  51
  52 Namespace::Namespace()
  53     : type(FALLBACK_NAMESPACE),
  54       is_pattern(false),
  55       is_executable(false) {
  56 }
  57
  58 Namespace::Namespace(
  59     NamespaceType type, const GURL& url, const GURL& target, bool is_pattern)
  60     : type(type),
  61       namespace_url(url),
  62       target_url(target),
  63       is_pattern(is_pattern),
  64       is_executable(false) {
  65 }
  66
  67 Namespace::Namespace(
  68     NamespaceType type, const GURL& url, const GURL& target,
  69     bool is_pattern, bool is_executable)
  70     : type(type),
  71       namespace_url(url),
  72       target_url(target),
  73       is_pattern(is_pattern),
  74       is_executable(is_executable) {
  75 }
  76
  77 Namespace::~Namespace() {
  78 }
  79
  80 bool Namespace::IsMatch(const GURL& url) const {
  81   if (is_pattern) {
  82     // We have to escape '?' characters since MatchPattern also treats those
  83     // as wildcards which we don't want here, we only do '*'s.
  84     std::string pattern = namespace_url.spec();
  85     if (namespace_url.has_query())
  86       ReplaceSubstringsAfterOffset(&pattern, 0, "?", "\\?");
  87     return MatchPattern(url.spec(), pattern);
  88   }
  89   return StartsWithASCII(url.spec(), namespace_url.spec(), true);
  90 }
  91
  92 bool IsSchemeSupported(const GURL& url) {
  93   bool supported = url.SchemeIs(kHttpScheme) || url.SchemeIs(kHttpsScheme) ||
  94       url.SchemeIs(kDevToolsScheme);
  95
  96 #ifndef NDEBUG
  97   // TODO(michaeln): It would be really nice if this could optionally work for
  98   // file and filesystem urls too to help web developers experiment and test
  99   // their apps, perhaps enabled via a cmd line flag or some other developer
 100   // tool setting.  Unfortunately file scheme net::URLRequests don't produce the
 101   // same signalling (200 response codes, headers) as http URLRequests, so this
 102   // doesn't work just yet.
 103   // supported |= url.SchemeIsFile();
 104 #endif
 105   return supported;
 106 }
 107
 108 bool IsMethodSupported(const std::string& method) {
 109   return (method == kHttpGETMethod) || (method == kHttpHEADMethod);
 110 }
 111
 112 bool IsSchemeAndMethodSupported(const net::URLRequest* request) {
 113   return IsSchemeSupported(request->url()) &&
 114          IsMethodSupported(request->method());
 115 }
 116
 117 }  // namespace appcache