Rename some appcache types in preparation for moving to content namespace

content/browser/appcache/appcache_host_unittest.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/appcache/mock_appcache_policy.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "net/url_request/url_request.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/appcache/appcache.h"
 #include "webkit/browser/appcache/appcache_backend_impl.h"
 #include "webkit/browser/appcache/appcache_group.h"
 #include "webkit/browser/appcache/appcache_host.h"
 #include "webkit/browser/quota/quota_manager.h"
 
 using appcache::AppCache;
 using appcache::AppCacheBackendImpl;
 using appcache::AppCacheEntry;
 using appcache::AppCacheFrontend;
 using appcache::AppCacheGroup;
 using appcache::AppCacheHost;
 using appcache::kNoCacheId;
 using appcache::ERROR_EVENT;
 using appcache::OBSOLETE;
 using appcache::OBSOLETE_EVENT;
 using appcache::PROGRESS_EVENT;
-using appcache::Status;
+using appcache::AppCacheStatus;
 using appcache::UNCACHED;
 
 namespace content {
 
 class AppCacheHostTest : public testing::Test {
  public:
   AppCacheHostTest() {
     get_status_callback_ =
         base::Bind(&AppCacheHostTest::GetStatusCallback,
                    base::Unretained(this));
@@ skipping 16 matching lines @@
     }
 
     virtual void OnCacheSelected(
         int host_id, const appcache::AppCacheInfo& info) OVERRIDE {
       last_host_id_ = host_id;
       last_cache_id_ = info.cache_id;
       last_status_ = info.status;
     }
 
     virtual void OnStatusChanged(const std::vector<int>& host_ids,
-                                 appcache::Status status) OVERRIDE {
+                                 appcache::AppCacheStatus status) OVERRIDE {
       last_status_changed_ = status;
     }
 
     virtual void OnEventRaised(const std::vector<int>& host_ids,
-                               appcache::EventID event_id) OVERRIDE {
+                               appcache::AppCacheEventID event_id) OVERRIDE {
       last_event_id_ = event_id;
     }
 
-    virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
-                                    const appcache::ErrorDetails& details)
-        OVERRIDE {
+    virtual void OnErrorEventRaised(
+        const std::vector<int>& host_ids,
+        const appcache::AppCacheErrorDetails& details) OVERRIDE {
       last_event_id_ = ERROR_EVENT;
     }
 
     virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
                                        const GURL& url,
                                        int num_total,
                                        int num_complete) OVERRIDE {
       last_event_id_ = PROGRESS_EVENT;
     }
 
     virtual void OnLogMessage(int host_id,
-                              appcache::LogLevel log_level,
+                              appcache::AppCacheLogLevel log_level,
                               const std::string& message) OVERRIDE {
     }
 
     virtual void OnContentBlocked(int host_id,
                                   const GURL& manifest_url) OVERRIDE {
       content_blocked_ = true;
     }
 
     int last_host_id_;
     int64 last_cache_id_;
-    appcache::Status last_status_;
-    appcache::Status last_status_changed_;
-    appcache::EventID last_event_id_;
+    appcache::AppCacheStatus last_status_;
+    appcache::AppCacheStatus last_status_changed_;
+    appcache::AppCacheEventID last_event_id_;
     bool content_blocked_;
   };
 
   class MockQuotaManagerProxy : public quota::QuotaManagerProxy {
    public:
     MockQuotaManagerProxy() : QuotaManagerProxy(NULL, NULL) {}
 
     // Not needed for our tests.
     virtual void RegisterClient(quota::QuotaClient* client) OVERRIDE {}
     virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
@@ skipping 29 matching lines @@
       inuse_.clear();
     }
 
     // Map from origin to count of inuse notifications.
     std::map<GURL, int> inuse_;
 
    protected:
     virtual ~MockQuotaManagerProxy() {}
   };
 
-  void GetStatusCallback(Status status, void* param) {
+  void GetStatusCallback(AppCacheStatus status, void* param) {
     last_status_result_ = status;
     last_callback_param_ = param;
   }
 
   void StartUpdateCallback(bool result, void* param) {
     last_start_result_ = result;
     last_callback_param_ = param;
   }
 
   void SwapCacheCallback(bool result, void* param) {
     last_swap_result_ = result;
     last_callback_param_ = param;
   }
 
   base::MessageLoop message_loop_;
 
   // Mock classes for the 'host' to work with
   MockAppCacheService service_;
   MockFrontend mock_frontend_;
 
   // Mock callbacks we expect to receive from the 'host'
   appcache::GetStatusCallback get_status_callback_;
   appcache::StartUpdateCallback start_update_callback_;
   appcache::SwapCacheCallback swap_cache_callback_;
 
-  Status last_status_result_;
+  AppCacheStatus last_status_result_;
   bool last_swap_result_;
   bool last_start_result_;
   void* last_callback_param_;
 };
 
 TEST_F(AppCacheHostTest, Basic) {
   // Construct a host and test what state it appears to be in.
   AppCacheHost host(1, &mock_frontend_, &service_);
   EXPECT_EQ(1, host.host_id());
   EXPECT_EQ(&service_, host.service());
@@ skipping 355 matching lines @@
     EXPECT_EQ(&mock_frontend_, host.frontend());
     EXPECT_EQ(NULL, host.associated_cache());
     EXPECT_FALSE(host.is_selection_pending());
     EXPECT_TRUE(host.preferred_manifest_url().is_empty());
   }
   EXPECT_EQ(0, mock_quota_proxy->GetInUseCount(kDocAndOriginUrl));
   service_.set_quota_manager_proxy(NULL);
 }
 
 }  // namespace content