Move all remaining appcache-related code to content namespace

content/browser/appcache/appcache_update_job_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/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
+#include "content/browser/appcache/appcache_group.h"
+#include "content/browser/appcache/appcache_host.h"
+#include "content/browser/appcache/appcache_response.h"
+#include "content/browser/appcache/appcache_update_job.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webkit/browser/appcache/appcache_group.h"
-#include "webkit/browser/appcache/appcache_host.h"
-#include "webkit/browser/appcache/appcache_response.h"
-#include "webkit/browser/appcache/appcache_update_job.h"
-
-using appcache::AppCache;
-using appcache::AppCacheEntry;
-using appcache::AppCacheFrontend;
-using appcache::AppCacheHost;
-using appcache::AppCacheGroup;
-using appcache::AppCacheResponseInfo;
-using appcache::AppCacheUpdateJob;
-using appcache::AppCacheResponseWriter;
-using appcache::APPCACHE_CACHED_EVENT;
-using appcache::APPCACHE_CHECKING_EVENT;
-using appcache::APPCACHE_DOWNLOADING_EVENT;
-using appcache::APPCACHE_ERROR_EVENT;
-using appcache::AppCacheEventID;
-using appcache::APPCACHE_FALLBACK_NAMESPACE;
-using appcache::HttpResponseInfoIOBuffer;
-using appcache::kAppCacheNoCacheId;
-using appcache::kAppCacheNoResponseId;
-using appcache::Namespace;
-using appcache::APPCACHE_NETWORK_NAMESPACE;
-using appcache::APPCACHE_NO_UPDATE_EVENT;
-using appcache::APPCACHE_OBSOLETE_EVENT;
-using appcache::APPCACHE_PROGRESS_EVENT;
-using appcache::APPCACHE_UPDATE_READY_EVENT;
-using appcache::AppCacheStatus;
 
 namespace content {
 class AppCacheUpdateJobTest;
 
 namespace {
 
 const char kManifest1Contents[] =
     "CACHE MANIFEST\n"
     "explicit1\n"
     "FALLBACK:\n"
@@ skipping 180 matching lines @@
 
 class MockFrontend : public AppCacheFrontend {
  public:
   MockFrontend()
       : ignore_progress_events_(false), verify_progress_events_(false),
         last_progress_total_(-1), last_progress_complete_(-1),
         start_update_trigger_(APPCACHE_CHECKING_EVENT), update_(NULL) {
   }
 
   virtual void OnCacheSelected(
-      int host_id, const appcache::AppCacheInfo& info) OVERRIDE {
+      int host_id, const AppCacheInfo& info) OVERRIDE {
   }
 
   virtual void OnStatusChanged(const std::vector<int>& host_ids,
                                AppCacheStatus status) OVERRIDE {
   }
 
   virtual void OnEventRaised(const std::vector<int>& host_ids,
                              AppCacheEventID event_id) OVERRIDE {
     raised_events_.push_back(RaisedEvent(host_ids, event_id));
 
     // Trigger additional updates if requested.
     if (event_id == start_update_trigger_ && update_) {
       for (std::vector<AppCacheHost*>::iterator it = update_hosts_.begin();
            it != update_hosts_.end(); ++it) {
         AppCacheHost* host = *it;
         update_->StartUpdate(host,
             (host ? host->pending_master_entry_url() : GURL()));
       }
       update_hosts_.clear();  // only trigger once
     }
   }
 
   virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
-                                  const appcache::AppCacheErrorDetails& details)
+                                  const AppCacheErrorDetails& details)
       OVERRIDE {
     error_message_ = details.message;
     OnEventRaised(host_ids, APPCACHE_ERROR_EVENT);
   }
 
   virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
                                      const GURL& url,
                                      int num_total,
                                      int num_complete) OVERRIDE {
     if (!ignore_progress_events_)
@@ skipping 17 matching lines @@
         EXPECT_TRUE(url.is_empty());
       else
         EXPECT_TRUE(url.is_valid());
 
       last_progress_total_ = num_total;
       last_progress_complete_ = num_complete;
     }
   }
 
   virtual void OnLogMessage(int host_id,
-                            appcache::AppCacheLogLevel log_level,
+                            AppCacheLogLevel log_level,
                             const std::string& message) OVERRIDE {
   }
 
   virtual void OnContentBlocked(int host_id,
                                 const GURL& manifest_url) OVERRIDE {
   }
 
   void AddExpectedEvent(const std::vector<int>& host_ids,
       AppCacheEventID event_id) {
     DCHECK(!ignore_progress_events_ || event_id != APPCACHE_PROGRESS_EVENT);
@@ skipping 3171 matching lines @@
   MockFrontend::RaisedEvents events = mock_frontend.raised_events_;
   size_t expected = 2;
   EXPECT_EQ(expected, events.size());
   expected = 1;
   EXPECT_EQ(expected, events[0].first.size());
   EXPECT_EQ(host.host_id(), events[0].first[0]);
   EXPECT_EQ(APPCACHE_CHECKING_EVENT, events[0].second);
 
   EXPECT_EQ(expected, events[1].first.size());
   EXPECT_EQ(host.host_id(), events[1].first[0]);
-  EXPECT_EQ(appcache::APPCACHE_DOWNLOADING_EVENT, events[1].second);
+  EXPECT_EQ(APPCACHE_DOWNLOADING_EVENT, events[1].second);
 
   EXPECT_EQ(AppCacheGroup::DOWNLOADING, group->update_status());
 }
 
 TEST_F(AppCacheUpdateJobTest, StartCacheAttempt) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::StartCacheAttemptTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, StartUpgradeAttempt) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::StartUpgradeAttemptTest);
@@ skipping 199 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace content