AppCache INTERCEPT namespace.

webkit/appcache/appcache_storage_impl.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/appcache/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 44 matching lines @@
                                   std::vector<int64>* deletable_response_ids) {
   AppCacheDatabase::CacheRecord cache_record;
   bool success = false;
   if (database->FindCacheForGroup(group_id, &cache_record)) {
     database->FindResponseIdsForCacheAsVector(cache_record.cache_id,
                                               deletable_response_ids);
     success =
         database->DeleteGroup(group_id) &&
         database->DeleteCache(cache_record.cache_id) &&
         database->DeleteEntriesForCache(cache_record.cache_id) &&
-        database->DeleteFallbackNameSpacesForCache(cache_record.cache_id) &&
+        database->DeleteNamespacesForCache(cache_record.cache_id) &&
         database->DeleteOnlineWhiteListForCache(cache_record.cache_id) &&
         database->InsertDeletableResponseIds(*deletable_response_ids);
   } else {
     NOTREACHED() << "A existing group without a cache is unexpected";
     success = database->DeleteGroup(group_id);
   }
   return success;
 }
 
 // Deletes all appcache data (if clear_all_data is true), or session-only
@@ skipping 286 matching lines @@
   explicit StoreOrLoadTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
 
   bool FindRelatedCacheRecords(int64 cache_id);
   void CreateCacheAndGroupFromRecords(
       scoped_refptr<AppCache>* cache, scoped_refptr<AppCacheGroup>* group);
 
   AppCacheDatabase::GroupRecord group_record_;
   AppCacheDatabase::CacheRecord cache_record_;
   std::vector<AppCacheDatabase::EntryRecord> entry_records_;
-  std::vector<AppCacheDatabase::FallbackNameSpaceRecord>
+  std::vector<AppCacheDatabase::NamespaceRecord>
+      intercept_namespace_records_;
+  std::vector<AppCacheDatabase::NamespaceRecord>
       fallback_namespace_records_;
   std::vector<AppCacheDatabase::OnlineWhiteListRecord>
       online_whitelist_records_;
 };
 
 bool AppCacheStorageImpl::StoreOrLoadTask::FindRelatedCacheRecords(
     int64 cache_id) {
   return database_->FindEntriesForCache(cache_id, &entry_records_) &&
-         database_->FindFallbackNameSpacesForCache(
-             cache_id, &fallback_namespace_records_) &&
+         database_->FindNamespacesForCache(
+             cache_id, &intercept_namespace_records_,
+             &fallback_namespace_records_) &&
          database_->FindOnlineWhiteListForCache(
              cache_id, &online_whitelist_records_);
 }
 
 void AppCacheStorageImpl::StoreOrLoadTask::CreateCacheAndGroupFromRecords(
     scoped_refptr<AppCache>* cache, scoped_refptr<AppCacheGroup>* group) {
   DCHECK(storage_ && cache && group);
 
   (*cache) = storage_->working_set_.GetCache(cache_record_.cache_id);
   if (cache->get()) {
     (*group) = cache->get()->owning_group();
     DCHECK(group->get());
     DCHECK_EQ(group_record_.group_id, group->get()->group_id());
     storage_->NotifyStorageAccessed(group_record_.origin);
     return;
   }
 
   (*cache) = new AppCache(storage_->service_, cache_record_.cache_id);
   cache->get()->InitializeWithDatabaseRecords(
-      cache_record_, entry_records_, fallback_namespace_records_,
+      cache_record_, entry_records_,
+      intercept_namespace_records_,
+      fallback_namespace_records_,
       online_whitelist_records_);
   cache->get()->set_complete(true);
 
   (*group) = storage_->working_set_.GetGroup(group_record_.manifest_url);
   if (group->get()) {
     DCHECK(group_record_.group_id == group->get()->group_id());
     group->get()->AddCache(cache->get());
   } else {
     (*group) = new AppCacheGroup(
         storage_->service_, group_record_.manifest_url,
@@ skipping 128 matching lines @@
 AppCacheStorageImpl::StoreGroupAndCacheTask::StoreGroupAndCacheTask(
     AppCacheStorageImpl* storage, AppCacheGroup* group, AppCache* newest_cache)
     : StoreOrLoadTask(storage), group_(group), cache_(newest_cache),
       success_(false), would_exceed_quota_(false),
       space_available_(-1), new_origin_usage_(-1) {
   group_record_.group_id = group->group_id();
   group_record_.manifest_url = group->manifest_url();
   group_record_.origin = group_record_.manifest_url.GetOrigin();
   newest_cache->ToDatabaseRecords(
       group,
-      &cache_record_, &entry_records_, &fallback_namespace_records_,
+      &cache_record_, &entry_records_,
+      &intercept_namespace_records_,
+      &fallback_namespace_records_,
       &online_whitelist_records_);
 }
 
 void AppCacheStorageImpl::StoreGroupAndCacheTask::GetQuotaThenSchedule() {
   quota::QuotaManager* quota_manager = NULL;
   if (storage_->service()->quota_manager_proxy()) {
     quota_manager =
         storage_->service()->quota_manager_proxy()->quota_manager();
   }
 
@@ skipping 69 matching lines @@
       // The rest are deletable.
       std::set<int64>::const_iterator id_iter = existing_response_ids.begin();
       while (id_iter != existing_response_ids.end()) {
         newly_deletable_response_ids_.push_back(*id_iter);
         ++id_iter;
       }
 
       success_ =
           database_->DeleteCache(cache.cache_id) &&
           database_->DeleteEntriesForCache(cache.cache_id) &&
-          database_->DeleteFallbackNameSpacesForCache(cache.cache_id) &&
+          database_->DeleteNamespacesForCache(cache.cache_id) &&
           database_->DeleteOnlineWhiteListForCache(cache.cache_id) &&
           database_->InsertDeletableResponseIds(newly_deletable_response_ids_);
           // TODO(michaeln): store group_id too with deletable ids
     } else {
       NOTREACHED() << "A existing group without a cache is unexpected";
     }
   }
 
   success_ =
       success_ &&
       database_->InsertCache(&cache_record_) &&
       database_->InsertEntryRecords(entry_records_) &&
-      database_->InsertFallbackNameSpaceRecords(fallback_namespace_records_)&&
+      database_->InsertNamespaceRecords(intercept_namespace_records_) &&
+      database_->InsertNamespaceRecords(fallback_namespace_records_) &&
       database_->InsertOnlineWhiteListRecords(online_whitelist_records_);
 
   if (!success_)
     return;
 
   new_origin_usage_ = database_->GetOriginUsage(group_record_.origin);
 
   // Only check quota when the new usage exceeds the old usage.
   if (new_origin_usage_ <= old_origin_usage) {
     success_ = transaction.Commit();
@@ skipping 48 matching lines @@
 void AppCacheStorageImpl::StoreGroupAndCacheTask::CancelCompletion() {
   // Overriden to safely drop our reference to the group and cache
   // which are not thread safe refcounted.
   DatabaseTask::CancelCompletion();
   group_ = NULL;
   cache_ = NULL;
 }
 
 // FindMainResponseTask -------
 
-class AppCacheStorageImpl::FindMainResponseTask : public DatabaseTask {
- public:
-  FindMainResponseTask(AppCacheStorageImpl* storage,
-                       const GURL& url,
-                       const GURL& preferred_manifest_url,
-                       const AppCacheWorkingSet::GroupMap* groups_in_use)
-      : DatabaseTask(storage), url_(url),
-        preferred_manifest_url_(preferred_manifest_url),
-        cache_id_(kNoCacheId), group_id_(0) {
-    if (groups_in_use) {
-      for (AppCacheWorkingSet::GroupMap::const_iterator it =
-               groups_in_use->begin();
-           it != groups_in_use->end(); ++it) {
-        AppCacheGroup* group = it->second;
-        AppCache* cache = group->newest_complete_cache();
-        if (group->is_obsolete() || !cache)
-          continue;
-        cache_ids_in_use_.insert(cache->cache_id());
-      }
-    }
-  }
-
-  virtual void Run();
-  virtual void RunCompleted();
-
- private:
-  typedef std::vector<AppCacheDatabase::FallbackNameSpaceRecord*>
-      FallbackNameSpaceVector;
-  bool FindExactMatch(int64 preferred_id);
-  bool FindFallback(int64 preferred_id);
-  bool FindFirstValidFallback(const FallbackNameSpaceVector& fallbacks);
-
-  GURL url_;
-  GURL preferred_manifest_url_;
-  std::set<int64> cache_ids_in_use_;
-  AppCacheEntry entry_;
-  AppCacheEntry fallback_entry_;
-  GURL fallback_url_;
-  int64 cache_id_;
-  int64 group_id_;
-  GURL manifest_url_;
-};
-
 // Helpers for FindMainResponseTask::Run()
 namespace {
 class SortByCachePreference
     : public std::binary_function<
         AppCacheDatabase::EntryRecord,
         AppCacheDatabase::EntryRecord,
         bool> {
  public:
   SortByCachePreference(int64 preferred_id, const std::set<int64>& in_use_ids)
       : preferred_id_(preferred_id), in_use_ids_(in_use_ids) {
   }
   bool operator()(
       const AppCacheDatabase::EntryRecord& lhs,
       const AppCacheDatabase::EntryRecord& rhs) {
     return compute_value(lhs) > compute_value(rhs);
   }
  private:
   int compute_value(const AppCacheDatabase::EntryRecord& entry) {
     if (entry.cache_id == preferred_id_)
       return 100;
     else if (in_use_ids_.find(entry.cache_id) != in_use_ids_.end())
       return 50;
     return 0;
   }
   int64 preferred_id_;
   const std::set<int64>& in_use_ids_;
 };
 
 bool SortByLength(
-    const AppCacheDatabase::FallbackNameSpaceRecord& lhs,
-    const AppCacheDatabase::FallbackNameSpaceRecord& rhs) {
+    const AppCacheDatabase::NamespaceRecord& lhs,
+    const AppCacheDatabase::NamespaceRecord& rhs) {
   return lhs.namespace_url.spec().length() > rhs.namespace_url.spec().length();
 }
 
 class NetworkNamespaceHelper {
  public:
   explicit NetworkNamespaceHelper(AppCacheDatabase* database)
       : database_(database) {
   }
 
   bool IsInNetworkNamespace(const GURL& url, int64 cache_id) {
@@ skipping 23 matching lines @@
   }
 
   // Key is cache id
   typedef std::map<int64, std::vector<GURL> > WhiteListMap;
   WhiteListMap namespaces_map_;
   AppCacheDatabase* database_;
 };
 
 }  // namespace
 
+class AppCacheStorageImpl::FindMainResponseTask : public DatabaseTask {
+ public:
+  FindMainResponseTask(AppCacheStorageImpl* storage,
+                       const GURL& url,
+                       const GURL& preferred_manifest_url,
+                       const AppCacheWorkingSet::GroupMap* groups_in_use)
+      : DatabaseTask(storage), url_(url),
+        preferred_manifest_url_(preferred_manifest_url),
+        cache_id_(kNoCacheId), group_id_(0) {
+    if (groups_in_use) {
+      for (AppCacheWorkingSet::GroupMap::const_iterator it =
+               groups_in_use->begin();
+           it != groups_in_use->end(); ++it) {
+        AppCacheGroup* group = it->second;
+        AppCache* cache = group->newest_complete_cache();
+        if (group->is_obsolete() || !cache)
+          continue;
+        cache_ids_in_use_.insert(cache->cache_id());
+      }
+    }
+  }
+
+  virtual void Run();
+  virtual void RunCompleted();
+
+ private:
+  typedef std::vector<AppCacheDatabase::NamespaceRecord*>
+      NamespaceRecordPtrVector;
+  bool FindExactMatch(int64 preferred_id);
+  bool FindNamespaceMatch(int64 preferred_id);
+  bool FindNamespaceHelper(
+      int64 preferred_cache_id,
+      AppCacheDatabase::NamespaceRecordVector* namespaces,
+      NetworkNamespaceHelper* network_namespace_helper);
+  bool FindFirstValidNamespace(const NamespaceRecordPtrVector& namespaces);
+
+  GURL url_;
+  GURL preferred_manifest_url_;
+  std::set<int64> cache_ids_in_use_;
+  AppCacheEntry entry_;
+  AppCacheEntry fallback_entry_;
+  GURL fallback_url_;
+  int64 cache_id_;
+  int64 group_id_;
+  GURL manifest_url_;
+};
+
+
+
 void AppCacheStorageImpl::FindMainResponseTask::Run() {
   // NOTE: The heuristics around choosing amoungst multiple candidates
   // is underspecified, and just plain not fully understood. This needs
   // to be refined.
 
   // The 'preferred_manifest_url' is the url of the manifest associated
   // with the page that opened or embedded the page being loaded now.
   // We have a strong preference to use resources from that cache.
   // We also have a lesser bias to use resources from caches that are currently
   // being used by other unrelated pages.
   // TODO(michaeln): come up with a 'preferred_manifest_url' in more cases
   // - when navigating a frame whose current contents are from an appcache
   // - when clicking an href in a frame that is appcached
   int64 preferred_cache_id = kNoCacheId;
   if (!preferred_manifest_url_.is_empty()) {
     AppCacheDatabase::GroupRecord preferred_group;
     AppCacheDatabase::CacheRecord preferred_cache;
     if (database_->FindGroupForManifestUrl(
             preferred_manifest_url_, &preferred_group) &&
         database_->FindCacheForGroup(
             preferred_group.group_id, &preferred_cache)) {
       preferred_cache_id = preferred_cache.cache_id;
     }
   }
 
-  // TODO(michaeln): Also lookup matches in intercept namespaces.
-  // http://code.google.com/p/chromium/issues/detail?id=101565
   if (FindExactMatch(preferred_cache_id) ||
-      FindFallback(preferred_cache_id)) {
+      FindNamespaceMatch(preferred_cache_id)) {
     // We found something.
     DCHECK(cache_id_ != kNoCacheId && !manifest_url_.is_empty() &&
            group_id_ != 0);
     return;
   }
 
   // We didn't find anything.
   DCHECK(cache_id_ == kNoCacheId && manifest_url_.is_empty() &&
          group_id_ == 0);
 }
@@ skipping 19 matching lines @@
       group_id_ = group_record.group_id;
       entry_ = AppCacheEntry(iter->flags, iter->response_id);
       cache_id_ = iter->cache_id;
       return true;  // We found an exact match.
     }
   }
   return false;
 }
 
 bool AppCacheStorageImpl::
-FindMainResponseTask::FindFallback(int64 preferred_cache_id) {
-  std::vector<AppCacheDatabase::FallbackNameSpaceRecord> all_fallbacks;
-  if (!database_->FindFallbackNameSpacesForOrigin(
-          url_.GetOrigin(), &all_fallbacks)
-      || all_fallbacks.empty()) {
+FindMainResponseTask::FindNamespaceMatch(int64 preferred_cache_id) {
+  AppCacheDatabase::NamespaceRecordVector all_intercepts;
+  AppCacheDatabase::NamespaceRecordVector all_fallbacks;
+  if (!database_->FindNamespacesForOrigin(
+          url_.GetOrigin(), &all_intercepts, &all_fallbacks)
+      || (all_intercepts.empty() && all_fallbacks.empty())) {
     return false;
   }
 
+  NetworkNamespaceHelper network_namespace_helper(database_);
+  if (FindNamespaceHelper(preferred_cache_id,
+                          &all_intercepts,
+                          &network_namespace_helper) ||
+      FindNamespaceHelper(preferred_cache_id,
+                          &all_fallbacks,
+                          &network_namespace_helper)) {
+    return true;
+  }
+  return false;
+}
+
+bool AppCacheStorageImpl::
+FindMainResponseTask::FindNamespaceHelper(
+    int64 preferred_cache_id,
+    AppCacheDatabase::NamespaceRecordVector* namespaces,
+    NetworkNamespaceHelper* network_namespace_helper) {
   // Sort them by length, longer matches within the same cache/bucket take
   // precedence.
-  std::sort(all_fallbacks.begin(), all_fallbacks.end(), SortByLength);
+  std::sort(namespaces->begin(), namespaces->end(), SortByLength);
 
-  // Filter the list and bin them into buckets.
-  NetworkNamespaceHelper network_namespace_helper(database_);
-  FallbackNameSpaceVector preferred_fallbacks;
-  FallbackNameSpaceVector inuse_fallbacks;
-  FallbackNameSpaceVector other_fallbacks;
-  std::vector<AppCacheDatabase::FallbackNameSpaceRecord>::iterator iter;
-  for (iter = all_fallbacks.begin(); iter < all_fallbacks.end(); ++iter) {
+  NamespaceRecordPtrVector preferred_namespaces;
+  NamespaceRecordPtrVector inuse_namespaces;
+  NamespaceRecordPtrVector other_namespaces;
+  std::vector<AppCacheDatabase::NamespaceRecord>::iterator iter;
+  for (iter = namespaces->begin(); iter < namespaces->end(); ++iter) {
     // Skip those that aren't a prefix match.
     if (!StartsWithASCII(url_.spec(), iter->namespace_url.spec(), true))
       continue;
 
-    // Skip fallback namespaces where the requested url falls into a network
+    // Skip namespaces where the requested url falls into a network
     // namespace of its containing appcache.
-    if (network_namespace_helper.IsInNetworkNamespace(url_, iter->cache_id))
+    if (network_namespace_helper->IsInNetworkNamespace(url_, iter->cache_id))
       continue;
 
     // Bin them into one of our three buckets.
     if (iter->cache_id == preferred_cache_id)
-      preferred_fallbacks.push_back(&(*iter));
+      preferred_namespaces.push_back(&(*iter));
     else if (cache_ids_in_use_.find(iter->cache_id) != cache_ids_in_use_.end())
-      inuse_fallbacks.push_back(&(*iter));
+      inuse_namespaces.push_back(&(*iter));
     else
-      other_fallbacks.push_back(&(*iter));
+      other_namespaces.push_back(&(*iter));
   }
 
-  if (FindFirstValidFallback(preferred_fallbacks) ||
-      FindFirstValidFallback(inuse_fallbacks) ||
-      FindFirstValidFallback(other_fallbacks))
+  if (FindFirstValidNamespace(preferred_namespaces) ||
+      FindFirstValidNamespace(inuse_namespaces) ||
+      FindFirstValidNamespace(other_namespaces))
     return true;  // We found one.
 
   // We didn't find anything.
   return false;
 }
 
 bool AppCacheStorageImpl::
-FindMainResponseTask::FindFirstValidFallback(
-    const FallbackNameSpaceVector& fallbacks) {
+FindMainResponseTask::FindFirstValidNamespace(
+    const NamespaceRecordPtrVector& namespaces) {
   // Take the first with a valid, non-foreign entry.
-  FallbackNameSpaceVector::const_iterator iter;
-  for (iter = fallbacks.begin(); iter < fallbacks.end();  ++iter) {
+  NamespaceRecordPtrVector::const_iterator iter;
+  for (iter = namespaces.begin(); iter < namespaces.end();  ++iter) {
     AppCacheDatabase::EntryRecord entry_record;
-    if (database_->FindEntry((*iter)->cache_id, (*iter)->fallback_entry_url,
+    if (database_->FindEntry((*iter)->cache_id, (*iter)->target_url,
                              &entry_record)) {
       AppCacheDatabase::GroupRecord group_record;
       if ((entry_record.flags & AppCacheEntry::FOREIGN) ||
           !database_->FindGroupForCache(entry_record.cache_id, &group_record)) {
         continue;
       }
       manifest_url_ = group_record.manifest_url;
       group_id_ = group_record.group_id;
       cache_id_ = (*iter)->cache_id;
-      fallback_url_ = (*iter)->fallback_entry_url;
-      fallback_entry_ = AppCacheEntry(
-          entry_record.flags, entry_record.response_id);
+      if ((*iter)->type == FALLBACK_NAMESPACE) {
+        fallback_url_ = (*iter)->target_url;
+        fallback_entry_ = AppCacheEntry(
+            entry_record.flags, entry_record.response_id);
+      } else {
+        entry_ = AppCacheEntry(entry_record.flags, entry_record.response_id);
+      }
       return true;  // We found one.
     }
   }
   return false;  // We didn't find a match.
 }
 
 void AppCacheStorageImpl::FindMainResponseTask::RunCompleted() {
   storage_->CallOnMainResponseFound(
       &delegates_, url_, entry_, fallback_url_, fallback_entry_,
       cache_id_, group_id_, manifest_url_);
@@ skipping 687 matching lines @@
     Disable();
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
       db_thread_->PostTask(
           FROM_HERE, base::Bind(&DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache