Switch to standard integer types in media/.

media/blink/resource_multibuffer_data_provider_unittest.cc

 // Copyright 2015 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 <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 88 matching lines @@
   }
 
   void Start() {
     InSequence s;
     EXPECT_CALL(*url_loader_,
                 loadAsynchronously(Truly(CorrectAcceptEncoding), loader_));
 
     loader_->Start();
   }
 
-  void FullResponse(int64 instance_size, bool ok = true) {
+  void FullResponse(int64_t instance_size, bool ok = true) {
     WebURLResponse response(gurl_);
     response.setHTTPHeaderField(
         WebString::fromUTF8("Content-Length"),
         WebString::fromUTF8(base::StringPrintf("%" PRId64, instance_size)));
     response.setExpectedContentLength(instance_size);
     response.setHTTPStatusCode(kHttpOK);
     loader_->didReceiveResponse(url_loader_, response);
 
     if (ok) {
       EXPECT_EQ(instance_size, url_data_->length());
     }
 
     EXPECT_FALSE(url_data_->range_supported());
   }
 
-  void PartialResponse(int64 first_position,
-                       int64 last_position,
-                       int64 instance_size) {
+  void PartialResponse(int64_t first_position,
+                       int64_t last_position,
+                       int64_t instance_size) {
     PartialResponse(first_position, last_position, instance_size, false, true);
   }
 
-  void PartialResponse(int64 first_position,
-                       int64 last_position,
-                       int64 instance_size,
+  void PartialResponse(int64_t first_position,
+                       int64_t last_position,
+                       int64_t instance_size,
                        bool chunked,
                        bool accept_ranges) {
     WebURLResponse response(gurl_);
     response.setHTTPHeaderField(
         WebString::fromUTF8("Content-Range"),
         WebString::fromUTF8(
             base::StringPrintf("bytes "
                                "%" PRId64 "-%" PRId64 "/%" PRId64,
                                first_position, last_position, instance_size)));
 
     // HTTP 1.1 doesn't permit Content-Length with Transfer-Encoding: chunked.
-    int64 content_length = -1;
+    int64_t content_length = -1;
     if (chunked) {
       response.setHTTPHeaderField(WebString::fromUTF8("Transfer-Encoding"),
                                   WebString::fromUTF8("chunked"));
     } else {
       content_length = last_position - first_position + 1;
     }
     response.setExpectedContentLength(content_length);
 
     // A server isn't required to return Accept-Ranges even though it might.
     if (accept_ranges) {
@@ skipping 36 matching lines @@
     loader_->didReceiveData(
         url_loader_, reinterpret_cast<char*>(data_ + position), size, size);
   }
 
   void WriteData(int size) {
     scoped_ptr<char[]> data(new char[size]);
     loader_->didReceiveData(url_loader_, data.get(), size, size);
   }
 
   // Verifies that data in buffer[0...size] is equal to data_[pos...pos+size].
-  void VerifyBuffer(uint8* buffer, int pos, int size) {
+  void VerifyBuffer(uint8_t* buffer, int pos, int size) {
     EXPECT_EQ(0, memcmp(buffer, data_ + pos, size));
   }
 
   bool HasActiveLoader() { return loader_->active_loader_; }
   MOCK_METHOD1(RedirectCallback, void(const scoped_refptr<UrlData>&));
 
   void SetUrlData(const scoped_refptr<UrlData>& new_url_data) {
     url_data_ = new_url_data;
   }
 
  protected:
   GURL gurl_;
-  int64 first_position_;
+  int64_t first_position_;
 
   scoped_ptr<UrlIndex> url_index_;
   scoped_refptr<UrlData> url_data_;
   scoped_refptr<UrlData> redirected_to_;
   // The loader is owned by the UrlData above.
   ResourceMultiBufferDataProvider* loader_;
   NiceMock<MockWebURLLoader>* url_loader_;
 
   MockWebFrameClient client_;
   WebView* view_;
   WebLocalFrame* frame_;
 
   base::MessageLoop message_loop_;
 
-  uint8 data_[kDataSize];
+  uint8_t data_[kDataSize];
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ResourceMultiBufferDataProviderTest);
 };
 
 TEST_F(ResourceMultiBufferDataProviderTest, StartStop) {
   Initialize(kHttpUrl, 0);
   Start();
   StopWhenLoad();
 }
@@ skipping 80 matching lines @@
 TEST_F(ResourceMultiBufferDataProviderTest, TestRedirects) {
   // Test redirect.
   Initialize(kHttpUrl, 0);
   Start();
   Redirect(kHttpRedirect);
   FullResponse(1024);
   StopWhenLoad();
 }
 
 }  // namespace media