Switch to standard integer types in content/browser/.

content/browser/appcache/appcache_url_request_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 <stdint.h>
+
 #include <stack>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/pickle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/appcache_url_request_job.h"
 #include "content/browser/appcache/mock_appcache_service.h"
@@ skipping 98 matching lines @@
   // Test Harness -------------------------------------------------------------
   // TODO(michaeln): share this test harness with AppCacheResponseTest
 
   class MockStorageDelegate : public AppCacheStorage::Delegate {
    public:
     explicit MockStorageDelegate(AppCacheURLRequestJobTest* test)
         : loaded_info_id_(0), test_(test) {
     }
 
     void OnResponseInfoLoaded(AppCacheResponseInfo* info,
-                              int64 response_id) override {
+                              int64_t response_id) override {
       loaded_info_ = info;
       loaded_info_id_ = response_id;
       test_->ScheduleNextTask();
     }
 
     scoped_refptr<AppCacheResponseInfo> loaded_info_;
-    int64 loaded_info_id_;
+    int64_t loaded_info_id_;
     AppCacheURLRequestJobTest* test_;
   };
 
   class MockURLRequestDelegate : public net::URLRequest::Delegate {
    public:
     explicit MockURLRequestDelegate(AppCacheURLRequestJobTest* test)
         : test_(test),
           received_data_(new net::IOBuffer(kNumBlocks * kBlockSize)),
           did_receive_headers_(false), amount_received_(0),
           kill_after_amount_received_(0), kill_with_io_pending_(false) {
@@ skipping 337 matching lines @@
                                         nullptr, false,
                                         base::Bind(&ExpectNotRestarted)));
     job->DeliverNetworkResponse();
     EXPECT_TRUE(job->is_delivering_network_response());
     EXPECT_FALSE(job->has_been_started());
 
     job.reset(new AppCacheURLRequestJob(request.get(), nullptr, storage,
                                         nullptr, false,
                                         base::Bind(&ExpectNotRestarted)));
     const GURL kManifestUrl("http://blah/");
-    const int64 kCacheId(1);
-    const int64 kGroupId(1);
+    const int64_t kCacheId(1);
+    const int64_t kGroupId(1);
     const AppCacheEntry kEntry(AppCacheEntry::EXPLICIT, 1);
     job->DeliverAppCachedResponse(kManifestUrl, kCacheId, kGroupId,
                                   kEntry, false);
     EXPECT_FALSE(job->is_waiting());
     EXPECT_TRUE(job->is_delivering_appcache_response());
     EXPECT_FALSE(job->has_been_started());
     EXPECT_EQ(kManifestUrl, job->manifest_url());
     EXPECT_EQ(kCacheId, job->cache_id());
     EXPECT_EQ(kGroupId, job->group_id());
     EXPECT_EQ(kEntry.types(), job->entry().types());
@@ skipping 248 matching lines @@
   void VerifyDeliverPartialResponse() {
     EXPECT_TRUE(request_->status().is_success());
     EXPECT_EQ(3, url_request_delegate_->amount_received_);
     EXPECT_EQ(0, memcmp(kHttpBasicBody + 1,
                         url_request_delegate_->received_data_->data(),
                         3));
     net::HttpResponseHeaders* headers =
         url_request_delegate_->received_info_.headers.get();
     EXPECT_EQ(206, headers->response_code());
     EXPECT_EQ(3, headers->GetContentLength());
-    int64 range_start, range_end, object_size;
+    int64_t range_start, range_end, object_size;
     EXPECT_TRUE(
         headers->GetContentRange(&range_start, &range_end, &object_size));
     EXPECT_EQ(1, range_start);
     EXPECT_EQ(3, range_end);
     EXPECT_EQ(5, object_size);
     TestFinished();
   }
 
   // CancelRequest --------------------------------------
 
@@ skipping 54 matching lines @@
   scoped_ptr<MockStorageDelegate> storage_delegate_;
   scoped_ptr<MockAppCacheService> service_;
   std::stack<std::pair<base::Closure, bool> > task_stack_;
 
   scoped_ptr<AppCacheResponseReader> reader_;
   scoped_refptr<HttpResponseInfoIOBuffer> read_info_buffer_;
   scoped_refptr<IOBuffer> read_buffer_;
   int expected_read_result_;
   int reader_deletion_count_down_;
 
-  int64 written_response_id_;
+  int64_t written_response_id_;
   scoped_ptr<AppCacheResponseWriter> writer_;
   scoped_refptr<HttpResponseInfoIOBuffer> write_info_buffer_;
   scoped_refptr<IOBuffer> write_buffer_;
   int expected_write_result_;
   int writer_deletion_count_down_;
 
   bool restart_callback_invoked_;
 
   scoped_ptr<MockURLRequestJobFactory> job_factory_;
   scoped_ptr<net::URLRequestContext> empty_context_;
@@ skipping 36 matching lines @@
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequest) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequest);
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
 }  // namespace content