Split AppCacheService into appcache_service.h and appcache_service_impl.h

One will (eventually) go into content/public/browser/ and the other will go in content/browser/appcache/

BUG=338338
TBR=darin@chromium.org

Review URL: https://codereview.chromium.org/315733004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@275093 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 66 insertions, 66 deletions

diff --git a/content/browser/appcache/appcache_group_unittest.cc b/content/browser/appcache/appcache_group_unittest.cc
index fee6c63..b1df135 100644
--- a/content/browser/appcache/appcache_group_unittest.cc
+++ b/content/browser/appcache/appcache_group_unittest.cc
@@ -17,7 +17,7 @@ using appcache::AppCache;
 using appcache::AppCacheFrontend;
 using appcache::AppCacheGroup;
 using appcache::AppCacheHost;
-using appcache::AppCacheService;
+using appcache::AppCacheServiceImpl;
 using appcache::AppCacheUpdateJob;
 
 namespace {
@@ -90,7 +90,7 @@ class TestUpdateObserver : public AppCacheGroup::UpdateObserver {
 class TestAppCacheHost : public AppCacheHost {
  public:
   TestAppCacheHost(int host_id, AppCacheFrontend* frontend,
-                   AppCacheService* service)
+                   AppCacheServiceImpl* service)
       : AppCacheHost(host_id, frontend, service),
         update_completed_(false) {
   }
diff --git a/content/browser/appcache/appcache_interceptor.cc b/content/browser/appcache/appcache_interceptor.cc
index 3a2c2bd..069d2fd 100644
--- a/content/browser/appcache/appcache_interceptor.cc
+++ b/content/browser/appcache/appcache_interceptor.cc
@@ -7,14 +7,14 @@
 #include "webkit/browser/appcache/appcache_backend_impl.h"
 #include "webkit/browser/appcache/appcache_host.h"
 #include "webkit/browser/appcache/appcache_request_handler.h"
-#include "webkit/browser/appcache/appcache_service.h"
+#include "webkit/browser/appcache/appcache_service_impl.h"
 #include "webkit/browser/appcache/appcache_url_request_job.h"
 #include "webkit/common/appcache/appcache_interfaces.h"
 
 using appcache::AppCacheBackendImpl;
 using appcache::AppCacheHost;
 using appcache::AppCacheRequestHandler;
-using appcache::AppCacheService;
+using appcache::AppCacheServiceImpl;
 using appcache::kNoCacheId;
 using appcache::kNoHostId;
 
@@ -37,7 +37,7 @@ AppCacheRequestHandler* AppCacheInterceptor::GetHandler(
 }
 
 void AppCacheInterceptor::SetExtraRequestInfo(
-    net::URLRequest* request, AppCacheService* service, int process_id,
+    net::URLRequest* request, AppCacheServiceImpl* service, int process_id,
     int host_id, ResourceType::Type resource_type) {
   if (!service || (host_id == kNoHostId))
     return;
diff --git a/content/browser/appcache/appcache_interceptor.h b/content/browser/appcache/appcache_interceptor.h
index bb21b2f..d8da181 100644
--- a/content/browser/appcache/appcache_interceptor.h
+++ b/content/browser/appcache/appcache_interceptor.h
@@ -13,7 +13,7 @@
 
 namespace appcache {
 class AppCacheRequestHandler;
-class AppCacheService;
+class AppCacheServiceImpl;
 }
 
 namespace content {
@@ -31,7 +31,7 @@ class CONTENT_EXPORT AppCacheInterceptor
 
   // Must be called to make a request eligible for retrieval from an appcache.
   static void SetExtraRequestInfo(net::URLRequest* request,
-                                  appcache::AppCacheService* service,
+                                  appcache::AppCacheServiceImpl* service,
                                   int process_id,
                                   int host_id,
                                   ResourceType::Type resource_type);
diff --git a/content/browser/appcache/appcache_quota_client_unittest.cc b/content/browser/appcache/appcache_quota_client_unittest.cc
index 0bfed08..3a32e95 100644
--- a/content/browser/appcache/appcache_quota_client_unittest.cc
+++ b/content/browser/appcache/appcache_quota_client_unittest.cc
@@ -277,7 +277,7 @@ TEST_F(AppCacheQuotaClientTest, DeleteOriginData) {
   Call_NotifyAppCacheReady(client);
 
   // Perm deletions are short circuited in the Client and
-  // should not reach the AppCacheService.
+  // should not reach the AppCacheServiceImpl.
   EXPECT_EQ(quota::kQuotaStatusOk,
             DeleteOriginData(client, kPerm, kOriginA));
   EXPECT_EQ(0, mock_service_.delete_called_count());
diff --git a/content/browser/appcache/appcache_service_unittest.cc b/content/browser/appcache/appcache_service_unittest.cc
index f965cb3..80016a9 100644
--- a/content/browser/appcache/appcache_service_unittest.cc
+++ b/content/browser/appcache/appcache_service_unittest.cc
@@ -14,7 +14,7 @@
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/appcache/appcache_response.h"
-#include "webkit/browser/appcache/appcache_service.h"
+#include "webkit/browser/appcache/appcache_service_impl.h"
 
 using appcache::AppCache;
 using appcache::AppCacheEntry;
@@ -23,7 +23,7 @@ using appcache::AppCacheInfo;
 using appcache::AppCacheInfoCollection;
 using appcache::AppCacheInfoVector;
 using appcache::AppCacheResponseReader;
-using appcache::AppCacheService;
+using appcache::AppCacheServiceImpl;
 using appcache::HttpResponseInfoIOBuffer;
 
 namespace content {
@@ -90,15 +90,15 @@ class MockResponseReader : public AppCacheResponseReader {
 }  // namespace
 
 
-class AppCacheServiceTest : public testing::Test {
+class AppCacheServiceImplTest : public testing::Test {
  public:
-  AppCacheServiceTest()
+  AppCacheServiceImplTest()
       : kOrigin("http://hello/"),
         kManifestUrl(kOrigin.Resolve("manifest")),
-        service_(new AppCacheService(NULL)),
+        service_(new AppCacheServiceImpl(NULL)),
         delete_result_(net::OK), delete_completion_count_(0),
         deletion_callback_(
-            base::Bind(&AppCacheServiceTest::OnDeleteAppCachesComplete,
+            base::Bind(&AppCacheServiceImplTest::OnDeleteAppCachesComplete,
                        base::Unretained(this))) {
     // Setup to use mock storage.
     service_->storage_.reset(new MockAppCacheStorage(service_.get()));
@@ -180,7 +180,7 @@ class AppCacheServiceTest : public testing::Test {
   const GURL kOrigin;
   const GURL kManifestUrl;
 
-  scoped_ptr<AppCacheService> service_;
+  scoped_ptr<AppCacheServiceImpl> service_;
   int delete_result_;
   int delete_completion_count_;
   net::CompletionCallback deletion_callback_;
@@ -189,7 +189,7 @@ class AppCacheServiceTest : public testing::Test {
   base::MessageLoop message_loop_;
 };
 
-TEST_F(AppCacheServiceTest, DeleteAppCachesForOrigin) {
+TEST_F(AppCacheServiceImplTest, DeleteAppCachesForOrigin) {
   // Without giving mock storage simiulated info, should fail.
   service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback_);
   EXPECT_EQ(0, delete_completion_count_);
@@ -255,7 +255,7 @@ TEST_F(AppCacheServiceTest, DeleteAppCachesForOrigin) {
   EXPECT_EQ(0, delete_completion_count_);
 }
 
-TEST_F(AppCacheServiceTest, CheckAppCacheResponse) {
+TEST_F(AppCacheServiceImplTest, CheckAppCacheResponse) {
   // Check a non-existing manifest.
   EXPECT_FALSE(IsGroupStored(kManifestUrl));
   service_->CheckAppCacheResponse(kManifestUrl, 1, 1);
@@ -327,14 +327,14 @@ TEST_F(AppCacheServiceTest, CheckAppCacheResponse) {
 }
 
 // Just tests the backoff scheduling function, not the actual reinit function.
-TEST_F(AppCacheServiceTest, ScheduleReinitialize) {
+TEST_F(AppCacheServiceImplTest, ScheduleReinitialize) {
   const base::TimeDelta kNoDelay;
   const base::TimeDelta kOneSecond(base::TimeDelta::FromSeconds(1));
   const base::TimeDelta k30Seconds(base::TimeDelta::FromSeconds(30));
   const base::TimeDelta kOneHour(base::TimeDelta::FromHours(1));
 
   // Do things get initialized as expected?
-  scoped_ptr<AppCacheService> service(new AppCacheService(NULL));
+  scoped_ptr<AppCacheServiceImpl> service(new AppCacheServiceImpl(NULL));
   EXPECT_TRUE(service->last_reinit_time_.is_null());
   EXPECT_FALSE(service->reinit_timer_.IsRunning());
   EXPECT_EQ(kNoDelay, service->next_reinit_delay_);
diff --git a/content/browser/appcache/appcache_storage_impl_unittest.cc b/content/browser/appcache/appcache_storage_impl_unittest.cc
index e4a745d..16391d0 100644
--- a/content/browser/appcache/appcache_storage_impl_unittest.cc
+++ b/content/browser/appcache/appcache_storage_impl_unittest.cc
@@ -30,7 +30,7 @@
 #include "webkit/browser/appcache/appcache_group.h"
 #include "webkit/browser/appcache/appcache_host.h"
 #include "webkit/browser/appcache/appcache_request_handler.h"
-#include "webkit/browser/appcache/appcache_service.h"
+#include "webkit/browser/appcache/appcache_service_impl.h"
 #include "webkit/browser/appcache/appcache_storage_impl.h"
 #include "webkit/browser/quota/quota_manager.h"
 
@@ -43,7 +43,7 @@ using appcache::AppCacheFrontend;
 using appcache::AppCacheHost;
 using appcache::AppCacheInfo;
 using appcache::AppCacheGroup;
-using appcache::AppCacheService;
+using appcache::AppCacheServiceImpl;
 using appcache::AppCacheStorage;
 using appcache::AppCacheStorageImpl;
 using appcache::AppCacheStorageReference;
@@ -420,7 +420,7 @@ class AppCacheStorageImplTest : public testing::Test {
 
   void SetUpTest() {
     DCHECK(base::MessageLoop::current() == io_thread->message_loop());
-    service_.reset(new AppCacheService(NULL));
+    service_.reset(new AppCacheServiceImpl(NULL));
     service_->Initialize(
         base::FilePath(), db_thread->message_loop_proxy().get(), NULL);
     mock_quota_manager_proxy_ = new MockQuotaManagerProxy();
@@ -1601,7 +1601,7 @@ class AppCacheStorageImplTest : public testing::Test {
   // and involves other appcache classes to get some code
   // coverage thruout when Reinitialize happens.
 
-  class MockServiceObserver : public AppCacheService::Observer {
+  class MockServiceObserver : public AppCacheServiceImpl::Observer {
    public:
     explicit MockServiceObserver(AppCacheStorageImplTest* test)
         : test_(test) {}
@@ -1715,7 +1715,7 @@ class AppCacheStorageImplTest : public testing::Test {
     }
 
     // Recreate the service to point at the db and corruption on disk.
-    service_.reset(new AppCacheService(NULL));
+    service_.reset(new AppCacheServiceImpl(NULL));
     service_->set_request_context(io_thread->request_context());
     service_->Initialize(
         temp_directory_.path(),
@@ -1826,7 +1826,7 @@ class AppCacheStorageImplTest : public testing::Test {
 
   // Test case helpers --------------------------------------------------
 
-  AppCacheService* service() {
+  AppCacheServiceImpl* service() {
     return service_.get();
   }
 
@@ -1883,7 +1883,7 @@ class AppCacheStorageImplTest : public testing::Test {
 
   scoped_ptr<base::WaitableEvent> test_finished_event_;
   std::stack<base::Closure> task_stack_;
-  scoped_ptr<AppCacheService> service_;
+  scoped_ptr<AppCacheServiceImpl> service_;
   scoped_ptr<MockStorageDelegate> delegate_;
   scoped_refptr<MockQuotaManagerProxy> mock_quota_manager_proxy_;
   scoped_refptr<AppCacheGroup> group_;
diff --git a/content/browser/appcache/chrome_appcache_service.cc b/content/browser/appcache/chrome_appcache_service.cc
index 006b0a3..c72c218 100644
--- a/content/browser/appcache/chrome_appcache_service.cc
+++ b/content/browser/appcache/chrome_appcache_service.cc
@@ -17,7 +17,7 @@ namespace content {
 
 ChromeAppCacheService::ChromeAppCacheService(
     quota::QuotaManagerProxy* quota_manager_proxy)
-    : AppCacheService(quota_manager_proxy),
+    : AppCacheServiceImpl(quota_manager_proxy),
       resource_context_(NULL) {
 }
 
diff --git a/content/browser/appcache/chrome_appcache_service.h b/content/browser/appcache/chrome_appcache_service.h
index 61eafc1..2f33d9b 100644
--- a/content/browser/appcache/chrome_appcache_service.h
+++ b/content/browser/appcache/chrome_appcache_service.h
@@ -10,7 +10,7 @@
 #include "base/sequenced_task_runner_helpers.h"
 #include "content/common/content_export.h"
 #include "webkit/browser/appcache/appcache_policy.h"
-#include "webkit/browser/appcache/appcache_service.h"
+#include "webkit/browser/appcache/appcache_service_impl.h"
 #include "webkit/browser/quota/special_storage_policy.h"
 
 namespace base {
@@ -26,7 +26,7 @@ class ResourceContext;
 
 struct ChromeAppCacheServiceDeleter;
 
-// An AppCacheService subclass used by the chrome. There is an instance
+// An AppCacheServiceImpl subclass used by the chrome. There is an instance
 // associated with each BrowserContext. This derivation adds refcounting
 // semantics since a browser context has multiple URLRequestContexts which refer
 // to the same object, and those URLRequestContexts are refcounted independently
@@ -35,12 +35,12 @@ struct ChromeAppCacheServiceDeleter;
 // All methods, except the ctor, are expected to be called on
 // the IO thread (unless specifically called out in doc comments).
 //
-// TODO(dpranke): Fix dependencies on AppCacheService so that we don't have
-// to worry about clients calling AppCacheService methods.
+// TODO(dpranke): Fix dependencies on AppCacheServiceImpl so that we don't have
+// to worry about clients calling AppCacheServiceImpl methods.
 class CONTENT_EXPORT ChromeAppCacheService
     : public base::RefCountedThreadSafe<ChromeAppCacheService,
                                         ChromeAppCacheServiceDeleter>,
-      NON_EXPORTED_BASE(public appcache::AppCacheService),
+      NON_EXPORTED_BASE(public appcache::AppCacheServiceImpl),
       NON_EXPORTED_BASE(public appcache::AppCachePolicy) {
  public:
   explicit ChromeAppCacheService(quota::QuotaManagerProxy* proxy);
diff --git a/content/browser/appcache/chrome_appcache_service_unittest.cc b/content/browser/appcache/chrome_appcache_service_unittest.cc
index ba0e144..1800d0b 100644
--- a/content/browser/appcache/chrome_appcache_service_unittest.cc
+++ b/content/browser/appcache/chrome_appcache_service_unittest.cc
@@ -71,7 +71,7 @@ class ChromeAppCacheServiceTest : public testing::Test {
         io_thread_(BrowserThread::IO, &message_loop_) {}
 
  protected:
-  scoped_refptr<ChromeAppCacheService> CreateAppCacheService(
+  scoped_refptr<ChromeAppCacheService> CreateAppCacheServiceImpl(
       const base::FilePath& appcache_path,
       bool init_storage);
   void InsertDataIntoAppCache(ChromeAppCacheService* appcache_service);
@@ -91,7 +91,7 @@ class ChromeAppCacheServiceTest : public testing::Test {
 };
 
 scoped_refptr<ChromeAppCacheService>
-ChromeAppCacheServiceTest::CreateAppCacheService(
+ChromeAppCacheServiceTest::CreateAppCacheServiceImpl(
     const base::FilePath& appcache_path,
     bool init_storage) {
   scoped_refptr<ChromeAppCacheService> appcache_service =
@@ -150,7 +150,7 @@ TEST_F(ChromeAppCacheServiceTest, KeepOnDestruction) {
 
   // Create a ChromeAppCacheService and insert data into it
   scoped_refptr<ChromeAppCacheService> appcache_service =
-      CreateAppCacheService(appcache_path, true);
+      CreateAppCacheServiceImpl(appcache_path, true);
   ASSERT_TRUE(base::PathExists(appcache_path));
   ASSERT_TRUE(base::PathExists(appcache_path.AppendASCII("Index")));
   InsertDataIntoAppCache(appcache_service.get());
@@ -160,7 +160,7 @@ TEST_F(ChromeAppCacheServiceTest, KeepOnDestruction) {
   message_loop_.RunUntilIdle();
 
   // Recreate the appcache (for reading the data back)
-  appcache_service = CreateAppCacheService(appcache_path, false);
+  appcache_service = CreateAppCacheServiceImpl(appcache_path, false);
 
   // The directory is still there
   ASSERT_TRUE(base::PathExists(appcache_path));
@@ -187,7 +187,7 @@ TEST_F(ChromeAppCacheServiceTest, SaveSessionState) {
 
   // Create a ChromeAppCacheService and insert data into it
   scoped_refptr<ChromeAppCacheService> appcache_service =
-      CreateAppCacheService(appcache_path, true);
+      CreateAppCacheServiceImpl(appcache_path, true);
   ASSERT_TRUE(base::PathExists(appcache_path));
   ASSERT_TRUE(base::PathExists(appcache_path.AppendASCII("Index")));
   InsertDataIntoAppCache(appcache_service.get());
@@ -200,7 +200,7 @@ TEST_F(ChromeAppCacheServiceTest, SaveSessionState) {
   message_loop_.RunUntilIdle();
 
   // Recreate the appcache (for reading the data back)
-  appcache_service = CreateAppCacheService(appcache_path, false);
+  appcache_service = CreateAppCacheServiceImpl(appcache_path, false);
 
   // The directory is still there
   ASSERT_TRUE(base::PathExists(appcache_path));
diff --git a/content/browser/appcache/mock_appcache_service.h b/content/browser/appcache/mock_appcache_service.h
index 9b10598..691736b 100644
--- a/content/browser/appcache/mock_appcache_service.h
+++ b/content/browser/appcache/mock_appcache_service.h
@@ -7,18 +7,18 @@
 
 #include "base/compiler_specific.h"
 #include "content/browser/appcache/mock_appcache_storage.h"
-#include "webkit/browser/appcache/appcache_service.h"
+#include "webkit/browser/appcache/appcache_service_impl.h"
 #include "webkit/browser/quota/quota_manager.h"
 
-using appcache::AppCacheService;
+using appcache::AppCacheServiceImpl;
 
 namespace content {
 
 // For use by unit tests.
-class MockAppCacheService : public AppCacheService {
+class MockAppCacheService : public AppCacheServiceImpl {
  public:
   MockAppCacheService()
-    : AppCacheService(NULL),
+    : AppCacheServiceImpl(NULL),
       mock_delete_appcaches_for_origin_result_(net::OK),
       delete_called_count_(0) {
     storage_.reset(new MockAppCacheStorage(this));
diff --git a/content/browser/appcache/mock_appcache_storage.cc b/content/browser/appcache/mock_appcache_storage.cc
index ab233b0..e1c5c18 100644
--- a/content/browser/appcache/mock_appcache_storage.cc
+++ b/content/browser/appcache/mock_appcache_storage.cc
@@ -13,7 +13,7 @@
 #include "webkit/browser/appcache/appcache_entry.h"
 #include "webkit/browser/appcache/appcache_group.h"
 #include "webkit/browser/appcache/appcache_response.h"
-#include "webkit/browser/appcache/appcache_service.h"
+#include "webkit/browser/appcache/appcache_service_impl.h"
 
 // This is a quick and easy 'mock' implementation of the storage interface
 // that doesn't put anything to disk.
@@ -26,7 +26,7 @@
 // background thread.
 
 using appcache::AppCacheResponseWriter;
-using appcache::AppCacheService;
+using appcache::AppCacheServiceImpl;
 using appcache::FALLBACK_NAMESPACE;
 using appcache::INTERCEPT_NAMESPACE;
 using appcache::kNoCacheId;
@@ -34,7 +34,7 @@ using appcache::NamespaceType;
 
 namespace content {
 
-MockAppCacheStorage::MockAppCacheStorage(AppCacheService* service)
+MockAppCacheStorage::MockAppCacheStorage(AppCacheServiceImpl* service)
     : AppCacheStorage(service),
       simulate_make_group_obsolete_failure_(false),
       simulate_store_group_and_newest_cache_failure_(false),
diff --git a/content/browser/appcache/mock_appcache_storage.h b/content/browser/appcache/mock_appcache_storage.h
index 6875b5d..a9e9582 100644
--- a/content/browser/appcache/mock_appcache_storage.h
+++ b/content/browser/appcache/mock_appcache_storage.h
@@ -27,12 +27,12 @@ using appcache::AppCacheGroup;
 using appcache::AppCacheInfoCollection;
 using appcache::AppCacheResponseReader;
 using appcache::AppCacheResponseWriter;
-using appcache::AppCacheService;
+using appcache::AppCacheServiceImpl;
 using appcache::AppCacheStorage;
 using appcache::kNoCacheId;
 
 namespace content {
-FORWARD_DECLARE_TEST(AppCacheServiceTest, DeleteAppCachesForOrigin);
+FORWARD_DECLARE_TEST(AppCacheServiceImplTest, DeleteAppCachesForOrigin);
 FORWARD_DECLARE_TEST(MockAppCacheStorageTest, BasicFindMainResponse);
 FORWARD_DECLARE_TEST(MockAppCacheStorageTest,
                      BasicFindMainFallbackResponse);
@@ -48,7 +48,7 @@ FORWARD_DECLARE_TEST(MockAppCacheStorageTest, StoreExistingGroup);
 FORWARD_DECLARE_TEST(MockAppCacheStorageTest,
                      StoreExistingGroupExistingCache);
 class AppCacheRequestHandlerTest;
-class AppCacheServiceTest;
+class AppCacheServiceImplTest;
 class MockAppCacheStorageTest;
 
 // For use in unit tests.
@@ -57,7 +57,7 @@ class MockAppCacheStorageTest;
 // somewhat in parallel.
 class MockAppCacheStorage : public AppCacheStorage {
  public:
-  explicit MockAppCacheStorage(AppCacheService* service);
+  explicit MockAppCacheStorage(AppCacheServiceImpl* service);
   virtual ~MockAppCacheStorage();
 
   virtual void GetAllInfo(Delegate* delegate) OVERRIDE;
@@ -92,7 +92,7 @@ class MockAppCacheStorage : public AppCacheStorage {
 
  private:
   friend class AppCacheRequestHandlerTest;
-  friend class AppCacheServiceTest;
+  friend class AppCacheServiceImplTest;
   friend class AppCacheUpdateJobTest;
   friend class MockAppCacheStorageTest;
 
@@ -243,7 +243,7 @@ class MockAppCacheStorage : public AppCacheStorage {
                            StoreExistingGroup);
   FRIEND_TEST_ALL_PREFIXES(MockAppCacheStorageTest,
                            StoreExistingGroupExistingCache);
-  FRIEND_TEST_ALL_PREFIXES(AppCacheServiceTest,
+  FRIEND_TEST_ALL_PREFIXES(AppCacheServiceImplTest,
                            DeleteAppCachesForOrigin);
 
   DISALLOW_COPY_AND_ASSIGN(MockAppCacheStorage);
diff --git a/content/browser/appcache/view_appcache_internals_job.cc b/content/browser/appcache/view_appcache_internals_job.cc
index b6a3c3f..0cc64c3 100644
--- a/content/browser/appcache/view_appcache_internals_job.cc
+++ b/content/browser/appcache/view_appcache_internals_job.cc
@@ -28,14 +28,14 @@
 #include "webkit/browser/appcache/appcache_group.h"
 #include "webkit/browser/appcache/appcache_policy.h"
 #include "webkit/browser/appcache/appcache_response.h"
-#include "webkit/browser/appcache/appcache_service.h"
+#include "webkit/browser/appcache/appcache_service_impl.h"
 #include "webkit/browser/appcache/appcache_storage.h"
 
 using appcache::AppCacheGroup;
 using appcache::AppCacheInfo;
 using appcache::AppCacheInfoCollection;
 using appcache::AppCacheInfoVector;
-using appcache::AppCacheService;
+using appcache::AppCacheServiceImpl;
 using appcache::AppCacheStorage;
 using appcache::AppCacheStorageReference;
 using appcache::AppCacheResourceInfo;
@@ -116,7 +116,7 @@ void EmitCommandAnchor(const char* label,
 }
 
 void EmitAppCacheInfo(const GURL& base_url,
-                      AppCacheService* service,
+                      AppCacheServiceImpl* service,
                       const AppCacheInfo* info,
                       std::string* out) {
   std::string manifest_url_base64;
@@ -159,7 +159,7 @@ void EmitAppCacheInfo(const GURL& base_url,
 
 void EmitAppCacheInfoVector(
     const GURL& base_url,
-    AppCacheService* service,
+    AppCacheServiceImpl* service,
     const AppCacheInfoVector& appcaches,
     std::string* out) {
   for (std::vector<AppCacheInfo>::const_iterator info =
@@ -321,11 +321,11 @@ GURL ClearQuery(const GURL& url) {
 
 // Simple base class for the job subclasses defined here.
 class BaseInternalsJob : public net::URLRequestSimpleJob,
-                         public AppCacheService::Observer {
+                         public AppCacheServiceImpl::Observer {
  protected:
   BaseInternalsJob(net::URLRequest* request,
                    net::NetworkDelegate* network_delegate,
-                   AppCacheService* service)
+                   AppCacheServiceImpl* service)
       : URLRequestSimpleJob(request, network_delegate),
         appcache_service_(service),
         appcache_storage_(service->storage()) {
@@ -342,7 +342,7 @@ class BaseInternalsJob : public net::URLRequestSimpleJob,
       disabled_storage_reference_ = old_storage_ref;
   }
 
-  AppCacheService* appcache_service_;
+  AppCacheServiceImpl* appcache_service_;
   AppCacheStorage* appcache_storage_;
   scoped_refptr<AppCacheStorageReference> disabled_storage_reference_;
 };
@@ -352,7 +352,7 @@ class MainPageJob : public BaseInternalsJob {
  public:
   MainPageJob(net::URLRequest* request,
               net::NetworkDelegate* network_delegate,
-              AppCacheService* service)
+              AppCacheServiceImpl* service)
       : BaseInternalsJob(request, network_delegate, service),
         weak_factory_(this) {
   }
@@ -417,7 +417,7 @@ class RedirectToMainPageJob : public BaseInternalsJob {
  public:
   RedirectToMainPageJob(net::URLRequest* request,
                         net::NetworkDelegate* network_delegate,
-                        AppCacheService* service)
+                        AppCacheServiceImpl* service)
       : BaseInternalsJob(request, network_delegate, service) {}
 
   virtual int GetData(std::string* mime_type,
@@ -444,7 +444,7 @@ class RemoveAppCacheJob : public RedirectToMainPageJob {
   RemoveAppCacheJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
-      AppCacheService* service,
+      AppCacheServiceImpl* service,
       const GURL& manifest_url)
       : RedirectToMainPageJob(request, network_delegate, service),
         manifest_url_(manifest_url),
@@ -478,7 +478,7 @@ class ViewAppCacheJob : public BaseInternalsJob,
   ViewAppCacheJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
-      AppCacheService* service,
+      AppCacheServiceImpl* service,
       const GURL& manifest_url)
       : BaseInternalsJob(request, network_delegate, service),
         manifest_url_(manifest_url) {}
@@ -549,7 +549,7 @@ class ViewEntryJob : public BaseInternalsJob,
   ViewEntryJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
-      AppCacheService* service,
+      AppCacheServiceImpl* service,
       const GURL& manifest_url,
       const GURL& entry_url,
       int64 response_id, int64 group_id)
@@ -647,7 +647,7 @@ class ViewEntryJob : public BaseInternalsJob,
 net::URLRequestJob* ViewAppCacheInternalsJobFactory::CreateJobForRequest(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
-    AppCacheService* service) {
+    AppCacheServiceImpl* service) {
   if (!request->url().has_query())
     return new MainPageJob(request, network_delegate, service);
 
diff --git a/content/browser/appcache/view_appcache_internals_job.h b/content/browser/appcache/view_appcache_internals_job.h
index 44aa72c..f11b68e 100644
--- a/content/browser/appcache/view_appcache_internals_job.h
+++ b/content/browser/appcache/view_appcache_internals_job.h
@@ -14,7 +14,7 @@ class URLRequestJob;
 }
 
 namespace appcache {
-class AppCacheService;
+class AppCacheServiceImpl;
 }
 
 namespace content {
@@ -24,7 +24,7 @@ class ViewAppCacheInternalsJobFactory {
   static net::URLRequestJob* CreateJobForRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
-      appcache::AppCacheService* service);
+      appcache::AppCacheServiceImpl* service);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ViewAppCacheInternalsJobFactory);