Rename some appcache types in preparation for moving 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/mock_appcache_service.h"
@@ skipping 14 matching lines @@
 using appcache::AppCacheFrontend;
 using appcache::AppCacheHost;
 using appcache::AppCacheGroup;
 using appcache::AppCacheResponseInfo;
 using appcache::AppCacheUpdateJob;
 using appcache::AppCacheResponseWriter;
 using appcache::CACHED_EVENT;
 using appcache::CHECKING_EVENT;
 using appcache::DOWNLOADING_EVENT;
 using appcache::ERROR_EVENT;
-using appcache::EventID;
+using appcache::AppCacheEventID;
 using appcache::FALLBACK_NAMESPACE;
 using appcache::HttpResponseInfoIOBuffer;
 using appcache::kNoCacheId;
 using appcache::kNoResponseId;
 using appcache::Namespace;
 using appcache::NETWORK_NAMESPACE;
 using appcache::NO_UPDATE_EVENT;
 using appcache::OBSOLETE_EVENT;
 using appcache::PROGRESS_EVENT;
 using appcache::UPDATE_READY_EVENT;
-using appcache::Status;
+using appcache::AppCacheStatus;
 
 namespace content {
 class AppCacheUpdateJobTest;
 
 namespace {
 
 const char kManifest1Contents[] =
     "CACHE MANIFEST\n"
     "explicit1\n"
     "FALLBACK:\n"
@@ skipping 184 matching lines @@
       : ignore_progress_events_(false), verify_progress_events_(false),
         last_progress_total_(-1), last_progress_complete_(-1),
         start_update_trigger_(CHECKING_EVENT), update_(NULL) {
   }
 
   virtual void OnCacheSelected(
       int host_id, const appcache::AppCacheInfo& info) OVERRIDE {
   }
 
   virtual void OnStatusChanged(const std::vector<int>& host_ids,
-                               Status status) OVERRIDE {
+                               AppCacheStatus status) OVERRIDE {
   }
 
   virtual void OnEventRaised(const std::vector<int>& host_ids,
-                             EventID event_id) OVERRIDE {
+                             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::ErrorDetails& details)
+                                  const appcache::AppCacheErrorDetails& details)
       OVERRIDE {
     error_message_ = details.message;
     OnEventRaised(host_ids, 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::LogLevel log_level,
+                            appcache::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, EventID event_id) {
+  void AddExpectedEvent(const std::vector<int>& host_ids,
+      AppCacheEventID event_id) {
     DCHECK(!ignore_progress_events_ || event_id != PROGRESS_EVENT);
     expected_events_.push_back(RaisedEvent(host_ids, event_id));
   }
 
   void SetIgnoreProgressEvents(bool ignore) {
     // Some tests involve joining new hosts to an already running update job
     // or intentionally failing. The timing and sequencing of the progress
     // events generated by an update job are dependent on the behavior of
     // an external HTTP server. For jobs that do not run fully till completion,
     // due to either joining late or early exit, we skip monitoring the
     // progress events to avoid flakiness.
     ignore_progress_events_ = ignore;
   }
 
   void SetVerifyProgressEvents(bool verify) {
     verify_progress_events_ = verify;
   }
 
-  void TriggerAdditionalUpdates(EventID trigger_event,
+  void TriggerAdditionalUpdates(AppCacheEventID trigger_event,
                                 AppCacheUpdateJob* update) {
     start_update_trigger_ = trigger_event;
     update_ = update;
   }
 
   void AdditionalUpdateHost(AppCacheHost* host) {
     update_hosts_.push_back(host);
   }
 
   typedef std::vector<int> HostIds;
-  typedef std::pair<HostIds, EventID> RaisedEvent;
+  typedef std::pair<HostIds, AppCacheEventID> RaisedEvent;
   typedef std::vector<RaisedEvent> RaisedEvents;
   RaisedEvents raised_events_;
   std::string error_message_;
 
   // Set the expected events if verification needs to happen asynchronously.
   RaisedEvents expected_events_;
   std::string expected_error_message_;
 
   bool ignore_progress_events_;
 
   bool verify_progress_events_;
   int last_progress_total_;
   int last_progress_complete_;
 
   // Add ability for frontend to add master entries to an inprogress update.
-  EventID start_update_trigger_;
+  AppCacheEventID start_update_trigger_;
   AppCacheUpdateJob* update_;
   std::vector<AppCacheHost*> update_hosts_;
 };
 
 // Helper factories to simulate redirected URL responses for tests.
 class RedirectFactory : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
@@ skipping 3335 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace content