Switch to standard integer types in chrome/browser/, part 2 of 4.

chrome/browser/media/webrtc_rtp_dump_handler_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/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/media/webrtc_rtp_dump_handler.h"
 #include "chrome/browser/media/webrtc_rtp_dump_writer.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class FakeDumpWriter : public WebRtcRtpDumpWriter {
  public:
   FakeDumpWriter(size_t max_dump_size,
                  const base::Closure& max_size_reached_callback,
                  bool end_dump_success)
       : WebRtcRtpDumpWriter(base::FilePath(),
                             base::FilePath(),
                             max_dump_size,
                             base::Closure()),
         max_dump_size_(max_dump_size),
         current_dump_size_(0),
         max_size_reached_callback_(max_size_reached_callback),
         end_dump_success_(end_dump_success) {}
 
-  void WriteRtpPacket(const uint8* packet_header,
+  void WriteRtpPacket(const uint8_t* packet_header,
                       size_t header_length,
                       size_t packet_length,
                       bool incoming) override {
     current_dump_size_ += header_length;
     if (current_dump_size_ > max_dump_size_)
       max_size_reached_callback_.Run();
   }
 
   void EndDump(RtpDumpType type,
                const EndDumpCallback& finished_callback) override {
@@ skipping 111 matching lines @@
     base::RunLoop().RunUntilIdle();
     ResetDumpHandler(base::FilePath(), true);
   }
 }
 
 TEST_F(WebRtcRtpDumpHandlerTest, StoppedWhenMaxSizeReached) {
   std::string error;
 
   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_INCOMING, &error));
 
-  std::vector<uint8> buffer(100, 0);
+  std::vector<uint8_t> buffer(100, 0);
   handler_->OnRtpPacket(&buffer[0], buffer.size(), buffer.size(), true);
   base::RunLoop().RunUntilIdle();
 
   // Dumping should have been stopped, so ready to release.
   WebRtcRtpDumpHandler::ReleasedDumps dumps = handler_->ReleaseDumps();
   EXPECT_FALSE(dumps.incoming_dump_path.empty());
 }
 
 TEST_F(WebRtcRtpDumpHandlerTest, PacketIgnoredIfDumpingNotStarted) {
-  std::vector<uint8> buffer(100, 0);
+  std::vector<uint8_t> buffer(100, 0);
   handler_->OnRtpPacket(&buffer[0], buffer.size(), buffer.size(), true);
   handler_->OnRtpPacket(&buffer[0], buffer.size(), buffer.size(), false);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(WebRtcRtpDumpHandlerTest, PacketIgnoredIfDumpingStopped) {
   std::string error;
 
   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_INCOMING, &error));
 
   EXPECT_CALL(*this, OnStopDumpFinished(true, testing::_));
   handler_->StopDump(RTP_DUMP_INCOMING,
                      base::Bind(&WebRtcRtpDumpHandlerTest::OnStopDumpFinished,
                                 base::Unretained(this)));
 
-  std::vector<uint8> buffer(100, 0);
+  std::vector<uint8_t> buffer(100, 0);
   handler_->OnRtpPacket(&buffer[0], buffer.size(), buffer.size(), true);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(WebRtcRtpDumpHandlerTest, CannotStartMoreThanFiveDumps) {
   std::string error;
 
   handler_.reset();
 
   scoped_ptr<WebRtcRtpDumpHandler> handlers[6];
@@ skipping 202 matching lines @@
           this, &WebRtcRtpDumpHandlerTest::DeleteDumpHandler));
 
   EXPECT_TRUE(handler_->StartDump(RTP_DUMP_BOTH, &error));
 
   handler_->StopOngoingDumps(
       base::Bind(&WebRtcRtpDumpHandlerTest::OnStopOngoingDumpsFinished,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 }