Check for supported schemes and methods.

webkit/appcache/appcache_host.h

 // Copyright (c) 2009 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/observer_list.h"
 #include "base/ref_counted.h"
 #include "base/task.h"
 #include "base/weak_ptr.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/appcache/appcache_service.h"
 
 class URLRequest;
 
 namespace appcache {
 
 class AppCache;
 class AppCacheFrontend;
 class AppCacheGroup;
 class AppCacheRequestHandler;
 
 typedef Callback2<Status, void*>::Type GetStatusCallback;
 typedef Callback2<bool, void*>::Type StartUpdateCallback;
 typedef Callback2<bool, void*>::Type SwapCacheCallback;
 
 // Server-side representation of an application cache host.
 class AppCacheHost : public base::SupportsWeakPtr<AppCacheHost>,
                      public AppCacheService::LoadClient {
  public:
+
+  class Observer {
+   public:
+    // Called just after the cache selection algorithm completes.
+    virtual void OnCacheSelectionComplete(AppCacheHost* host) = 0;
+
+    // Called just prior to the instance being deleted.
+    virtual void OnDestructionImminent(AppCacheHost* host) = 0;
+
+    virtual ~Observer() {}
+  };
+
   AppCacheHost(int host_id, AppCacheFrontend* frontend,
                AppCacheService* service);
   ~AppCacheHost();
 
+  // Adds/removes an observer, the AppCacheHost does not take
+  // ownership of the observer.
+  void AddObserver(Observer* observer);
+  void RemoveObserver(Observer* observer);
+
   // Support for cache selection and scriptable method calls.
   void SelectCache(const GURL& document_url,
                    const int64 cache_document_was_loaded_from,
                    const GURL& manifest_url);
   void MarkAsForeignEntry(const GURL& document_url,
                           int64 cache_document_was_loaded_from);
   void GetStatusWithCallback(GetStatusCallback* callback,
                              void* callback_param);
   void StartUpdateWithCallback(StartUpdateCallback* callback,
                                void* callback_param);
@@ skipping 63 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_;
 
+  // List of objects observing us.
+  ObserverList<Observer> observers_;
+
   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);
   DISALLOW_COPY_AND_ASSIGN(AppCacheHost);
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_HOST_H_