Fix appcache_service and request_context referencing.

webkit/appcache/appcache_service.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_SERVICE_H_
 #define WEBKIT_APPCACHE_APPCACHE_SERVICE_H_
 
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/hash_tables.h"
 #include "base/file_path.h"
 #include "base/ref_counted.h"
 #include "base/task.h"
 #include "net/url_request/url_request_context.h"

[michaeln, 2009/09/22 01:59:12]

i've removed the #include in my local copy... class URLRequestContext is all
that's needed here

 #include "googleurl/src/gurl.h"
 
 namespace appcache {
 
 class AppCache;
 class AppCacheBackendImpl;
 class AppCacheGroup;
 
 // Class that manages the application cache service. Sends notifications
 // to many frontends.  One instance per user-profile. Each instance has
 // exclusive access to it's cache_directory on disk.
 class AppCacheService {
  public:
 
   class LoadClient {
    public:
     virtual ~LoadClient() {}
 
     // If a load fails the object pointer will be NULL.
     virtual void CacheLoadedCallback(AppCache* cache, int64 cache_id) = 0;
-    virtual void GroupLoadedCallback(AppCacheGroup* cache,
+    virtual void GroupLoadedCallback(AppCacheGroup* group,
                                      const GURL& manifest_url) = 0;
   };
 
   AppCacheService();
   virtual ~AppCacheService();
 
   void Initialize(const FilePath& cache_directory);
 
   // Context for use during cache updates, should only be accessed
-  // on the IO thread.
-  URLRequestContext* request_context() { return request_context_.get(); }
+  // on the IO thread. We do NOT add a reference to the request context,
+  // it is the callers responsibility to ensure that the pointer
+  // remains valid while set.
+  URLRequestContext* request_context() const { return request_context_; }
   void set_request_context(URLRequestContext* context) {
-    // TODO(michaeln): need to look into test failures that occur
-    // when we take this reference? Stubbing out for now.
-    // request_context_ = context;
+    request_context_ = context;
   }
 
   // TODO(jennb): API to set service settings, like file paths for storage
 
   // Track which processes are using this appcache service.
   void RegisterBackend(AppCacheBackendImpl* backend_impl);
   void UnregisterBackend(AppCacheBackendImpl* backend_impl);
   AppCacheBackendImpl* GetBackend(int id) {
     BackendMap::iterator it = backends_.find(id);
     return (it != backends_.end()) ? it->second : NULL;
   }
 
-  // Track what we have in or in-memory cache.
+  // Track what we have in our in-memory cache.
   void AddCache(AppCache* cache);
   void RemoveCache(AppCache* cache);
   void AddGroup(AppCacheGroup* group);
   void RemoveGroup(AppCacheGroup* group);
   AppCache* GetCache(int64 id) {
     CacheMap::iterator it = caches_.find(id);
     return (it != caches_.end()) ? it->second : NULL;
   }
   AppCacheGroup* GetGroup(const GURL& manifest_url) {
     GroupMap::iterator it = groups_.find(manifest_url);
@@ skipping 34 matching lines @@
   int64 last_response_id_;
 
   // Track current processes.  One 'backend' per child process.
   typedef std::map<int, AppCacheBackendImpl*> BackendMap;
   BackendMap backends_;
 
   // Where we save our data.
   FilePath cache_directory_;
 
   // Context for use during cache updates.
-  scoped_refptr<URLRequestContext> request_context_;
+  URLRequestContext* request_context_;
 
   // TODO(michaeln): cache and group loading book keeping.
   // TODO(michaeln): database and response storage
   // TODO(jennb): service state: e.g. reached quota?
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_SERVICE_H_