Switch to standard integer types in net/.

net/url_request/url_request_file_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 "net/url_request/url_request_file_job.h"
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 15 matching lines @@
 // OnReadComplete.
 class TestURLRequestFileJob : public URLRequestFileJob {
  public:
   // |seek_position| will be set to the value passed in to OnSeekComplete.
   // |observed_content| will be set to the concatenated data from all calls to
   // OnReadComplete.
   TestURLRequestFileJob(URLRequest* request,
                         NetworkDelegate* network_delegate,
                         const base::FilePath& file_path,
                         const scoped_refptr<base::TaskRunner>& file_task_runner,
-                        int64* seek_position,
+                        int64_t* seek_position,
                         std::string* observed_content)
       : URLRequestFileJob(request,
                           network_delegate,
                           file_path,
                           file_task_runner),
         seek_position_(seek_position),
         observed_content_(observed_content) {
     *seek_position_ = 0;
     observed_content_->clear();
   }
 
   ~TestURLRequestFileJob() override {}
 
  protected:
-  void OnSeekComplete(int64 result) override {
+  void OnSeekComplete(int64_t result) override {
     ASSERT_EQ(*seek_position_, 0);
     *seek_position_ = result;
   }
 
   void OnReadComplete(IOBuffer* buf, int result) override {
     observed_content_->append(std::string(buf->data(), result));
   }
 
-  int64* const seek_position_;
+  int64_t* const seek_position_;
   std::string* const observed_content_;
 };
 
 // A URLRequestJobFactory that will return TestURLRequestFileJob instances for
 // file:// scheme URLs.  Can only be used to create a single job.
 class TestJobFactory : public URLRequestJobFactory {
  public:
   TestJobFactory(const base::FilePath& path,
-                 int64* seek_position,
+                 int64_t* seek_position,
                  std::string* observed_content)
       : path_(path),
         seek_position_(seek_position),
         observed_content_(observed_content) {
     CHECK(seek_position_);
     CHECK(observed_content_);
   }
 
   ~TestJobFactory() override {}
 
@@ skipping 32 matching lines @@
   }
 
   bool IsSafeRedirectTarget(const GURL& location) const override {
     return false;
   }
 
  private:
   const base::FilePath path_;
 
   // These are mutable because MaybeCreateJobWithProtocolHandler is const.
-  mutable int64* seek_position_;
+  mutable int64_t* seek_position_;
   mutable std::string* observed_content_;
 };
 
 // Helper function to create a file in |directory| filled with
 // |content|. Returns true on succes and fills in |path| with the full path to
 // the file.
 bool CreateTempFileWithContent(const std::string& content,
                                const base::ScopedTempDir& directory,
                                base::FilePath* path) {
   if (!directory.IsValid())
@@ skipping 43 matching lines @@
 URLRequestFileJobEventsTest::URLRequestFileJobEventsTest() {}
 
 void URLRequestFileJobEventsTest::RunRequest(const std::string& content,
                                              const Range* range) {
   base::ScopedTempDir directory;
   ASSERT_TRUE(directory.CreateUniqueTempDir());
   base::FilePath path;
   ASSERT_TRUE(CreateTempFileWithContent(content, directory, &path));
 
   {
-    int64 seek_position;
+    int64_t seek_position;
     std::string observed_content;
     TestJobFactory factory(path, &seek_position, &observed_content);
     context_.set_job_factory(&factory);
 
     scoped_ptr<URLRequest> request(context_.CreateRequest(
         FilePathToFileURL(path), DEFAULT_PRIORITY, &delegate_));
     if (range) {
       ASSERT_GE(range->start, 0);
       ASSERT_GE(range->end, 0);
       ASSERT_LE(range->start, range->end);
@@ skipping 55 matching lines @@
   // Use a 15KB content file and read a range chosen somewhat arbitrarily but
   // not aligned on any likely page boundaries.
   int size = 15 * 1024;
   Range range(1701, (6 * 1024) + 3);
   RunRequest(MakeContentOfSize(size), &range);
 }
 
 }  // namespace
 
 }  // namespace net