NavigationController prototype

webkit/browser/appcache/appcache_host.cc

 // Copyright (c) 2011 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/browser/appcache/appcache_host.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
 #include "net/url_request/url_request.h"
 #include "webkit/browser/appcache/appcache.h"
 #include "webkit/browser/appcache/appcache_backend_impl.h"
 #include "webkit/browser/appcache/appcache_policy.h"
 #include "webkit/browser/appcache/appcache_request_handler.h"
 #include "webkit/browser/quota/quota_manager.h"
+#include "webkit/browser/appcache/manifest_parser.h"
 
 namespace appcache {
 
 namespace {
 
 void FillCacheInfo(const AppCache* cache,
                    const GURL& manifest_url,
                    Status status, AppCacheInfo* info) {
   info->manifest_url = manifest_url;
   info->status = status;
@@ skipping 32 matching lines @@
 
 AppCacheHost::~AppCacheHost() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDestructionImminent(this));
   if (associated_cache_.get())
     associated_cache_->UnassociateHost(this);
   if (group_being_updated_.get())
     group_being_updated_->RemoveUpdateObserver(this);
   service_->storage()->CancelDelegateCallbacks(this);
   if (service()->quota_manager_proxy() && !origin_in_use_.is_empty())
     service()->quota_manager_proxy()->NotifyOriginNoLongerInUse(origin_in_use_);
+  if (controller_group_)
+    controller_group_->RemoveUpdateObserver(this);
 }
 
 void AppCacheHost::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void AppCacheHost::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void AppCacheHost::SelectCache(const GURL& document_url,
                                const int64 cache_document_was_loaded_from,
                                const GURL& manifest_url) {
   DCHECK(pending_start_update_callback_.is_null() &&
          pending_swap_cache_callback_.is_null() &&
          pending_get_status_callback_.is_null() &&
          !is_selection_pending());
 
+  // Note: extra logic to release this cache in case an exe handler
+  // generated a redirect to a resource outside of the scope of this cache.
+  scoped_refptr<AppCache> main_cache_releaser = main_resource_cache_;
+  main_resource_cache_ = NULL;
+
   origin_in_use_ = document_url.GetOrigin();
   if (service()->quota_manager_proxy() && !origin_in_use_.is_empty())
     service()->quota_manager_proxy()->NotifyOriginInUse(origin_in_use_);
 
   if (main_resource_blocked_)
     frontend_->OnContentBlocked(host_id_,
                                 blocked_manifest_url_);
 
   // 6.9.6 The application cache selection algorithm.
   // The algorithm is started here and continues in FinishCacheSelection,
   // after cache or group loading is complete.
   // Note: Foreign entries are detected on the client side and
   // MarkAsForeignEntry is called in that case, so that detection
   // step is skipped here. See WebApplicationCacheHostImpl.cc
 
   if (cache_document_was_loaded_from != kNoCacheId) {
     LoadSelectedCache(cache_document_was_loaded_from);
     return;
   }
 
+  // Hackery for navcontroller semantics where the controller gets a crack
+  // and any and all subresource requests <period> for any documents in its
+  // controlled namespace. We force the containing cache to be associated.
+  if (main_cache_releaser &&
+      main_cache_releaser->owning_group()->IsFakeNavControllerGroup() &&
+      main_cache_releaser->FindInterceptNamespace(document_url))  {
+    LoadSelectedCache(main_cache_releaser->cache_id());
+    return;
+  }
+
   if (!manifest_url.is_empty() &&
       (manifest_url.GetOrigin() == document_url.GetOrigin())) {
     DCHECK(!first_party_url_.is_empty());
     AppCachePolicy* policy = service()->appcache_policy();
     if (policy &&
         !policy->CanCreateAppCache(manifest_url, first_party_url_)) {
       FinishCacheSelection(NULL, NULL);
       std::vector<int> host_ids(1, host_id_);
       frontend_->OnEventRaised(host_ids, CHECKING_EVENT);
       frontend_->OnErrorEventRaised(
@@ skipping 80 matching lines @@
          pending_get_status_callback_.is_null());
 
   pending_start_update_callback_ = callback;
   pending_callback_param_ = callback_param;
   if (is_selection_pending())
     return;
 
   DoPendingStartUpdate();
 }
 
+static void CreateControllerManifest(const GURL& manifest_url,
+                                     const string16& pattern,
+                                     const GURL& script_url,
+                                     Manifest* manifest) {
+  LOG(ERROR) << "CreateControllerManifest(" << manifest_url << ", " << pattern << ", " << script_url << ")";
+  // right now we only support prefix-like patterns
+  std::string pattern_utf8 = UTF16ToUTF8(pattern);
+  DCHECK(*pattern_utf8.rbegin() == '*') << "Only prefix patterns supported " << pattern_utf8;
+  base::StringPiece prefix_pattern(pattern_utf8.c_str(), pattern_utf8.length() - 1);
+
+  GURL namespace_url = manifest_url; // .Resolve(pattern);
+  manifest->intercept_namespaces.push_back(
+      Namespace(INTERCEPT_NAMESPACE, namespace_url,
+                script_url, true, true));
+  LOG(ERROR) << "   Created with namespace = " << namespace_url;
+}
+
+void AppCacheHost::RegisterController(const GURL& document_url,
+                                      const string16& pattern,
+                                      const GURL& script_url) {
+  LOG(ERROR) << "Browser process got registerController(" << pattern << ", " << script_url << ")";
+
+  if (!controller_pattern_.empty()) {
+    // You should be able to register any number of controllers at
+    // different prefixes, but we're not setup to do that.
+    LOG(ERROR) << "Trying to register pattern '" << pattern << "' with '" << script_url << "' but '" << controller_pattern_ << " has already been registered with '"<< controller_script_url_ << "'";
+    return;
+  }
+
+  controller_pattern_ = pattern;
+  controller_script_url_ = script_url;
+  controller_manifest_url_ = document_url.Resolve(pattern);
+  controller_group_ = NULL;
+  controller_cache_ = NULL;
+  service_->storage()->LoadOrCreateGroup(controller_manifest_url_, this);
+}
+
+void AppCacheHost::UnregisterController(const GURL& document_url,
+                                        const string16& pattern) {
+  // Clear out old state so register can be called again from the containing page.
+  if (controller_group_)
+    controller_group_->RemoveUpdateObserver(this);
+  controller_pattern_ = string16();
+  controller_script_url_ = GURL();
+  controller_manifest_url_ = GURL();
+  controller_group_ = NULL;
+  controller_cache_ = NULL;
+
+  // Delete the the 'controller cache' to unregister.
+  service_->DeleteAppCacheGroup(document_url.Resolve(pattern), net::CompletionCallback());
+}
+
 void AppCacheHost::DoPendingStartUpdate() {
   DCHECK_EQ(false, pending_start_update_callback_.is_null());
 
   // 6.9.8 Application cache API
   bool success = false;
   if (associated_cache_.get() && associated_cache_->owning_group()) {
     AppCacheGroup* group = associated_cache_->owning_group();
     if (!group->is_obsolete() && !group->is_being_deleted()) {
       success = true;
       group->StartUpdate();
@@ skipping 111 matching lines @@
 }
 
 void AppCacheHost::LoadOrCreateGroup(const GURL& manifest_url) {
   DCHECK(manifest_url.is_valid());
   pending_selected_manifest_url_ = manifest_url;
   service_->storage()->LoadOrCreateGroup(manifest_url, this);
 }
 
 void AppCacheHost::OnGroupLoaded(AppCacheGroup* group,
                                  const GURL& manifest_url) {
+  // special case
+  if (manifest_url == controller_manifest_url_) {
+    OnControllerGroupLoaded(group);
+    return;
+  }
+
   DCHECK(manifest_url == pending_selected_manifest_url_);
   pending_selected_manifest_url_ = GURL();
   FinishCacheSelection(NULL, group);
 }
 
+void AppCacheHost::OnControllerGroupLoaded(AppCacheGroup* group) {
+  DCHECK(group);
+  controller_group_ = group;            // hang onto it to keep it alive
+  if (group->HasCache()) {
+    // We already have a controller camping on this pattern.
+    // TODO: Need to see if it's exe handler url matches controller_script_url_,
+    // and to update/recreate if it doesn't match, for now assume it matches
+    // and just use it.
+    controller_cache_ = group->newest_complete_cache();
+    frontend_->OnControllerReady(host_id_);
+    return;
+  }
+
+  appcache::Manifest manifest;
+  CreateControllerManifest(controller_manifest_url_,
+                           controller_pattern_,
+                           controller_script_url_,
+                           &manifest);
+  // Nothing exists yet, need to run the update algo for the first time.
+  group->AddUpdateObserver(this);
+  group->StartUpdateWithFakeManifest(&manifest);
+}
+
+void AppCacheHost::OnControllerUpdateComplete(AppCacheGroup* group) {
+  if (group->HasCache())
+    controller_cache_ = group->newest_complete_cache();
+  DCHECK(controller_cache_);
+  frontend_->OnControllerReady(host_id_);
+}
+
 void AppCacheHost::LoadSelectedCache(int64 cache_id) {
   DCHECK(cache_id != kNoCacheId);
   pending_selected_cache_id_ = cache_id;
   service_->storage()->LoadCache(cache_id, this);
 }
 
 void AppCacheHost::OnCacheLoaded(AppCache* cache, int64 cache_id) {
   if (cache_id == pending_main_resource_cache_id_) {
     pending_main_resource_cache_id_ = kNoCacheId;
     main_resource_cache_ = cache;
@@ skipping 66 matching lines @@
 }
 
 void AppCacheHost::ObserveGroupBeingUpdated(AppCacheGroup* group) {
   DCHECK(!group_being_updated_.get());
   group_being_updated_ = group;
   newest_cache_of_group_being_updated_ = group->newest_complete_cache();
   group->AddUpdateObserver(this);
 }
 
 void AppCacheHost::OnUpdateComplete(AppCacheGroup* group) {
+  group->RemoveUpdateObserver(this);
+
+  if (group == controller_group_) {
+    OnControllerUpdateComplete(group);
+    return;
+  }
+
   DCHECK_EQ(group, group_being_updated_);
-  group->RemoveUpdateObserver(this);
 
   // Add a reference to the newest complete cache.
   SetSwappableCache(group);
 
   group_being_updated_ = NULL;
   newest_cache_of_group_being_updated_ = NULL;
 
   if (associated_cache_info_pending_ && associated_cache_.get() &&
       associated_cache_->is_complete()) {
     AppCacheInfo info;
@@ skipping 66 matching lines @@
   associated_cache_info_pending_ = cache && !cache->is_complete();
   AppCacheInfo info;
   if (cache)
     cache->AssociateHost(this);
 
   FillCacheInfo(cache, manifest_url, GetStatus(), &info);
   frontend_->OnCacheSelected(host_id_, info);
 }
 
 }  // namespace appcache