NavigationController prototype

webkit/common/appcache/appcache_interfaces.h

 // 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.
 
 #ifndef WEBKIT_COMMON_APPCACHE_APPCACHE_INTERFACES_H_
 #define WEBKIT_COMMON_APPCACHE_APPCACHE_INTERFACES_H_
 
+#include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/time/time.h"
 #include "url/gurl.h"
 #include "webkit/common/webkit_storage_common_export.h"
 
 namespace net {
 class URLRequest;
 }
 
 namespace appcache {
 
 // Defines constants, types, and abstract classes used in the main
 // process and in child processes.
 
 static const int kNoHostId = 0;
 static const int64 kNoCacheId = 0;
 static const int64 kNoResponseId = 0;
+static const int64 kSynthesizedResponseId = -1;
 static const int64 kUnknownCacheId = -1;
 
 enum Status {
   UNCACHED,
   IDLE,
   CHECKING,
   DOWNLOADING,
   UPDATE_READY,
   OBSOLETE
 };
@@ skipping 46 matching lines @@
   ~AppCacheResourceInfo();
 
   GURL url;
   int64 size;
   bool is_master;
   bool is_manifest;
   bool is_intercept;
   bool is_fallback;
   bool is_foreign;
   bool is_explicit;
+  bool is_executable;
+  std::string intercept_target_url;
   int64 response_id;
 };
 
 typedef std::vector<AppCacheResourceInfo> AppCacheResourceInfoVector;
 
 struct WEBKIT_STORAGE_COMMON_EXPORT Namespace {
   Namespace();  // Type is set to FALLBACK_NAMESPACE by default.
   Namespace(NamespaceType type, const GURL& url, const GURL& target,
             bool is_pattern);
   Namespace(NamespaceType type, const GURL& url, const GURL& target,
@@ skipping 22 matching lines @@
                              EventID event_id) = 0;
   virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
                                      const GURL& url,
                                      int num_total, int num_complete) = 0;
   virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
                                   const std::string& message) = 0;
   virtual void OnContentBlocked(int host_id,
                                 const GURL& manifest_url) = 0;
   virtual void OnLogMessage(int host_id, LogLevel log_level,
                             const std::string& message) = 0;
+  virtual void OnControllerReady(int host_id) = 0;
   virtual ~AppCacheFrontend() {}
 };
 
 // Interface used by frontend (renderer) to talk to backend (browser-process).
 class WEBKIT_STORAGE_COMMON_EXPORT AppCacheBackend {
  public:
   virtual void RegisterHost(int host_id) = 0;
   virtual void UnregisterHost(int host_id) = 0;
+  virtual void RegisterController(int host_id,
+                                  const GURL& document_url,
+                                  const string16& pattern,
+                                  const GURL& controller_url) = 0;
+  virtual void UnregisterController(int host_id,
+                                    const GURL& document_url,
+                                    const string16& pattern) = 0;
   virtual void SetSpawningHostId(int host_id, int spawning_host_id) = 0;
   virtual void SelectCache(int host_id,
                            const GURL& document_url,
                            const int64 cache_document_was_loaded_from,
                            const GURL& manifest_url) = 0;
   virtual void SelectCacheForWorker(
                            int host_id,
                            int parent_process_id,
                            int parent_host_id) = 0;
   virtual void SelectCacheForSharedWorker(
@@ skipping 26 matching lines @@
 WEBKIT_STORAGE_COMMON_EXPORT void AddSupportedScheme(const char* scheme);
 
 WEBKIT_STORAGE_COMMON_EXPORT bool IsSchemeSupported(const GURL& url);
 WEBKIT_STORAGE_COMMON_EXPORT bool IsMethodSupported(const std::string& method);
 WEBKIT_STORAGE_COMMON_EXPORT bool IsSchemeAndMethodSupported(
     const net::URLRequest* request);
 
 WEBKIT_STORAGE_COMMON_EXPORT extern const base::FilePath::CharType
     kAppCacheDatabaseName[];
 
+
+class WEBKIT_STORAGE_COMMON_EXPORT AppCacheExecutableHandlerInterfaces {
+ public:
+  struct WEBKIT_STORAGE_COMMON_EXPORT Request {
+    GURL url;
+    std::string method;                 /* probably an enum somewhere? */
+    std::string referrer;               /* string because URLRequest::referrer is a string */
+    std::map<std::string, std::string> headers;
+    bool is_main_resource_load;
+
+    Request();
+    ~Request();
+  };
+
+  // A handler can respond with either a response or defer to the network.
+  struct WEBKIT_STORAGE_COMMON_EXPORT Response {
+    int status_code;
+    string16 status_text;
+    string16 blob_id;
+    bool use_default;                   /* overrides all other settings */
+    std::map<string16, string16> headers;
+
+    Response();
+    ~Response();
+  };
+};
+
 }  // namespace
 
 #endif  // WEBKIT_COMMON_APPCACHE_APPCACHE_INTERFACES_H_