Switch to standard integer types in content/browser/.

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 <stddef.h>
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.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"
@@ skipping 1208 matching lines @@
                                                   group_->group_id()));
     cache->AddEntry(MockHttpServer::GetMockUrl("files/explicit1"),
                     AppCacheEntry(AppCacheEntry::EXPLICIT,
                                   response_writer_->response_id()));
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_old_cache_ = cache;
-    expect_response_ids_.insert(
-        std::map<GURL, int64>::value_type(
-            MockHttpServer::GetMockUrl("files/explicit1"),
-            response_writer_->response_id()));
+    expect_response_ids_.insert(std::map<GURL, int64_t>::value_type(
+        MockHttpServer::GetMockUrl("files/explicit1"),
+        response_writer_->response_id()));
     tested_manifest_ = MANIFEST1;
     MockFrontend::HostIds ids(1, host->host_id());
     frontend->AddExpectedEvent(ids, APPCACHE_CHECKING_EVENT);
     frontend->AddExpectedEvent(ids, APPCACHE_DOWNLOADING_EVENT);
     frontend->AddExpectedEvent(ids, APPCACHE_PROGRESS_EVENT);
     frontend->AddExpectedEvent(ids, APPCACHE_PROGRESS_EVENT);
     frontend->AddExpectedEvent(ids, APPCACHE_PROGRESS_EVENT);  // final
     frontend->AddExpectedEvent(ids, APPCACHE_UPDATE_READY_EVENT);
 
     // Seed storage with expected http response info for entry. Allow reuse.
@@ skipping 313 matching lines @@
     tested_manifest_ = MANIFEST1;
     expect_extra_entries_.insert(AppCache::EntryMap::value_type(
         MockHttpServer::GetMockUrl("files/explicit2"),
         AppCacheEntry(AppCacheEntry::MASTER)));  // foreign flag is dropped
     expect_extra_entries_.insert(AppCache::EntryMap::value_type(
         MockHttpServer::GetMockUrl("files/servererror"),
         AppCacheEntry(AppCacheEntry::MASTER)));
     expect_extra_entries_.insert(AppCache::EntryMap::value_type(
         MockHttpServer::GetMockUrl("files/notmodified"),
         AppCacheEntry(AppCacheEntry::EXPLICIT)));
-    expect_response_ids_.insert(std::map<GURL, int64>::value_type(
+    expect_response_ids_.insert(std::map<GURL, int64_t>::value_type(
         MockHttpServer::GetMockUrl("files/servererror"), 444));  // copied
-    expect_response_ids_.insert(std::map<GURL, int64>::value_type(
+    expect_response_ids_.insert(std::map<GURL, int64_t>::value_type(
         MockHttpServer::GetMockUrl("files/notmodified"), 555));  // copied
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, APPCACHE_CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, APPCACHE_DOWNLOADING_EVENT);
     frontend1->AddExpectedEvent(ids1, APPCACHE_PROGRESS_EVENT);  // explicit1
     frontend1->AddExpectedEvent(ids1, APPCACHE_PROGRESS_EVENT);  // fallback1a
     frontend1->AddExpectedEvent(ids1, APPCACHE_PROGRESS_EVENT);  // notfound
     frontend1->AddExpectedEvent(ids1, APPCACHE_PROGRESS_EVENT);  // explicit2
     frontend1->AddExpectedEvent(ids1, APPCACHE_PROGRESS_EVENT);  // servererror
     frontend1->AddExpectedEvent(ids1, APPCACHE_PROGRESS_EVENT);  // notmodified
@@ skipping 338 matching lines @@
 
   void MasterEntryFailStoreNewestCacheTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     MockAppCacheStorage* storage =
         reinterpret_cast<MockAppCacheStorage*>(service_->storage());
     storage->SimulateStoreGroupAndNewestCacheFailure();
 
     const GURL kManifestUrl = MockHttpServer::GetMockUrl("files/notmodified");
-    const int64 kManifestResponseId = 11;
+    const int64_t kManifestResponseId = 11;
 
     // Seed the response_info working set with canned data for
     // files/servererror and for files/notmodified to test that the
     // existing entries for those resource are reused by the update job.
     const char kData[] =
         "HTTP/1.1 200 OK\0"
         "Content-type: text/cache-manifest\0"
         "Last-Modified: Sat, 29 Oct 1994 19:43:31 GMT\0"
         "\0";
     const std::string kRawHeaders(kData, arraysize(kData));
@@ skipping 1106 matching lines @@
     service_.reset(NULL);
 
     event_->Signal();
   }
 
   void MakeService() {
     service_.reset(new MockAppCacheService());
     service_->set_request_context(io_thread_->request_context());
   }
 
-  AppCache* MakeCacheForGroup(int64 cache_id, int64 manifest_response_id) {
+  AppCache* MakeCacheForGroup(int64_t cache_id, int64_t manifest_response_id) {
     return MakeCacheForGroup(cache_id, group_->manifest_url(),
                              manifest_response_id);
   }
 
-  AppCache* MakeCacheForGroup(int64 cache_id, const GURL& manifest_entry_url,
-                              int64 manifest_response_id) {
+  AppCache* MakeCacheForGroup(int64_t cache_id,
+                              const GURL& manifest_entry_url,
+                              int64_t manifest_response_id) {
     AppCache* cache = new AppCache(service_->storage(), cache_id);
     cache->set_complete(true);
     cache->set_update_time(base::Time::Now() - kOneHour);
     group_->AddCache(cache);
     group_->set_last_full_update_check_time(cache->update_time());
 
     // Add manifest entry to cache.
     cache->AddEntry(manifest_entry_url,
         AppCacheEntry(AppCacheEntry::MANIFEST, manifest_response_id));
 
     // Specific tests that expect a newer time should set
     // expect_full_update_time_newer_than_ which causes this
     // equality expectation to be ignored.
     expect_full_update_time_equal_to_ = cache->update_time();
 
     return cache;
   }
 
   AppCacheHost* MakeHost(int host_id, AppCacheFrontend* frontend) {
     AppCacheHost* host = new AppCacheHost(host_id, frontend, service_.get());
     hosts_.push_back(host);
     return host;
   }
 
   AppCacheResponseInfo* MakeAppCacheResponseInfo(
-      const GURL& manifest_url, int64 response_id,
+      const GURL& manifest_url,
+      int64_t response_id,
       const std::string& raw_headers) {
     net::HttpResponseInfo* http_info = new net::HttpResponseInfo();
     http_info->headers = new net::HttpResponseHeaders(raw_headers);
     scoped_refptr<AppCacheResponseInfo> info(
         new AppCacheResponseInfo(service_->storage(), manifest_url,
                                  response_id, http_info, 0));
     response_infos_.push_back(info);
     return info.get();
   }
 
@@ skipping 61 matching lines @@
 
         // Check that all entries in the newest cache were stored.
         const AppCache::EntryMap& entries =
             group_->newest_complete_cache()->entries();
         for (AppCache::EntryMap::const_iterator it = entries.begin();
              it != entries.end(); ++it) {
           EXPECT_NE(kAppCacheNoResponseId, it->second.response_id());
 
           // Check that any copied entries have the expected response id
           // and that entries that are not copied have a different response id.
-          std::map<GURL, int64>::iterator found =
+          std::map<GURL, int64_t>::iterator found =
               expect_response_ids_.find(it->first);
           if (found != expect_response_ids_.end()) {
             EXPECT_EQ(found->second, it->second.response_id());
           } else if (expect_old_cache_) {
             AppCacheEntry* old_entry = expect_old_cache_->GetEntry(it->first);
             if (old_entry)
               EXPECT_NE(old_entry->response_id(), it->second.response_id());
           }
         }
       }
@@ skipping 255 matching lines @@
   bool expect_eviction_;
   base::Time expect_full_update_time_newer_than_;
   base::Time expect_full_update_time_equal_to_;
   AppCache* expect_old_cache_;
   AppCache* expect_newest_cache_;
   bool expect_non_null_update_time_;
   std::vector<MockFrontend*> frontends_;  // to check expected events
   TestedManifest tested_manifest_;
   const char* tested_manifest_path_override_;
   AppCache::EntryMap expect_extra_entries_;
-  std::map<GURL, int64> expect_response_ids_;
+  std::map<GURL, int64_t> expect_response_ids_;
 };
 
 TEST_F(AppCacheUpdateJobTest, AlreadyChecking) {
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), GURL("http://manifesturl.com"),
                         service.storage()->NewGroupId()));
 
   AppCacheUpdateJob update(&service, group.get());
 
@@ skipping 259 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace content