Indicate in the tab UI if appcache creation was blocked by privacy settings.

webkit/appcache/appcache_host.h

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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_APPCACHE_APPCACHE_HOST_H_
 #define WEBKIT_APPCACHE_APPCACHE_HOST_H_
 
 #include "base/callback.h"
 #include "base/observer_list.h"
 #include "base/ref_counted.h"
 #include "googleurl/src/gurl.h"
@@ skipping 64 matching lines @@
   // or by the update algorithm (see AppCacheUpdateJob).
   void AssociateCache(AppCache* cache);
 
   // Adds a reference to the newest complete cache in a group, unless it's the
   // same as the cache that is currently associated with the host.
   void SetSwappableCache(AppCacheGroup* group);
 
   // Used to ensure that a loaded appcache survives a frame navigation.
   void LoadMainResourceCache(int64 cache_id);
 
+  // Used to notify the host that a request was blocked by a policy.

[michaeln, 2010/04/08 18:17:42]

Maybe update the comment to say that the main resource was block, and rename the
method to NotifyMainResourceBlocked.

Its depending on be called prior to cache selection time to work properly. If
this gets called after cache selection time, its a noop. All resource loads
except the main resource load happen after cache selection.

So "main" is significant.

[jochen (gone - plz use gerrit), 2010/04/09 15:44:47]

Done.

+  void NotifyContentBlocked();
+
   // Used by the update job to keep track of which hosts are associated
   // with which pending master entries.
   const GURL& pending_master_entry_url() const {
     return new_master_entry_url_;
   }
 
   int host_id() const { return host_id_; }
   AppCacheService* service() const { return service_; }
   AppCacheFrontend* frontend() const { return frontend_; }
   AppCache* associated_cache() const { return associated_cache_.get(); }
@@ skipping 13 matching lines @@
   virtual void OnGroupLoaded(AppCacheGroup* group,
                              const GURL& manifest_url);
 
   void FinishCacheSelection(AppCache* cache, AppCacheGroup* group);
   void DoPendingGetStatus();
   void DoPendingStartUpdate();
   void DoPendingSwapCache();
 
   void ObserveGroupBeingUpdated(AppCacheGroup* group);
 
-  // AppCacheGroup::UpdateObserver method
+  // AppCacheGroup::UpdateObserver methods.
+  virtual void OnContentBlocked(AppCacheGroup* group);
   virtual void OnUpdateComplete(AppCacheGroup* group);
 
   // Identifies the corresponding appcache host in the child process.
   int host_id_;
 
   // The cache associated with this host, if any.
   scoped_refptr<AppCache> associated_cache_;
 
   // Hold a reference to the newest complete cache (if associated cache is
   // not the newest) to keep the newest cache in existence while the app cache
@@ skipping 32 matching lines @@
   // Since these are synchronous scriptable api calls in the client,
   // there can only be one type of callback pending.
   // Also, we have to wait until we have a cache selection prior
   // to responding to these calls, as cache selection involves
   // async loading of a cache or a group from storage.
   GetStatusCallback* pending_get_status_callback_;
   StartUpdateCallback* pending_start_update_callback_;
   SwapCacheCallback* pending_swap_cache_callback_;
   void* pending_callback_param_;
 
+  // True if requests for this host were blocked by a policy.
+  bool content_blocked_;
+
   // List of objects observing us.
   ObserverList<Observer> observers_;
 
   friend class AppCacheRequestHandlerTest;
   friend class AppCacheUpdateJobTest;
   FRIEND_TEST(AppCacheTest, CleanupUnusedCache);
   FRIEND_TEST(AppCacheGroupTest, CleanupUnusedGroup);
   FRIEND_TEST(AppCacheHostTest, Basic);
   FRIEND_TEST(AppCacheHostTest, SelectNoCache);
   FRIEND_TEST(AppCacheHostTest, ForeignEntry);
   FRIEND_TEST(AppCacheHostTest, FailedCacheLoad);
   FRIEND_TEST(AppCacheHostTest, FailedGroupLoad);
   FRIEND_TEST(AppCacheHostTest, SetSwappableCache);
   FRIEND_TEST(AppCacheGroupTest, QueueUpdate);
   DISALLOW_COPY_AND_ASSIGN(AppCacheHost);
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_HOST_H_