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