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

chrome/browser/download/save_page_browsertest.cc

 // Copyright (c) 2012 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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/macros.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_file_util.h"
+#include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/save_package_file_picker.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 92 matching lines @@
   PersistedFilter filter_;
   base::Closure quit_waiting_callback_;
   bool persisted_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadPersistedObserver);
 };
 
 // Waits for an item record to be removed from the downloads database.
 class DownloadRemovedObserver : public DownloadPersistedObserver {
  public:
-  DownloadRemovedObserver(Profile* profile, int32 download_id)
+  DownloadRemovedObserver(Profile* profile, int32_t download_id)
       : DownloadPersistedObserver(profile, PersistedFilter()),
         removed_(false),
         download_id_(download_id) {}
   ~DownloadRemovedObserver() override {}
 
   bool WaitForRemoved() {
     if (removed_)
       return true;
     base::RunLoop run_loop;
     quit_waiting_callback_ = run_loop.QuitClosure();
     run_loop.Run();
     quit_waiting_callback_ = base::Closure();
     return removed_;
   }
 
   void OnDownloadStored(DownloadItem* item,
                         const history::DownloadRow& info) override {}
 
   void OnDownloadsRemoved(const DownloadHistory::IdSet& ids) override {
     removed_ = ids.find(download_id_) != ids.end();
     if (removed_ && !quit_waiting_callback_.is_null())
       quit_waiting_callback_.Run();
   }
 
  private:
   bool removed_;
   base::Closure quit_waiting_callback_;
-  int32 download_id_;
+  int32_t download_id_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadRemovedObserver);
 };
 
-bool DownloadStoredProperly(
-    const GURL& expected_url,
-    const base::FilePath& expected_path,
-    int64 num_files,
-    history::DownloadState expected_state,
-    DownloadItem* item,
-    const history::DownloadRow& info) {
+bool DownloadStoredProperly(const GURL& expected_url,
+                            const base::FilePath& expected_path,
+                            int64_t num_files,
+                            history::DownloadState expected_state,
+                            DownloadItem* item,
+                            const history::DownloadRow& info) {
   // This function may be called multiple times for a given test. Returning
   // false doesn't necessarily mean that the test has failed or will fail, it
   // might just mean that the test hasn't passed yet.
   if (!expected_path.empty() && info.target_path != expected_path) {
     DVLOG(20) << __FUNCTION__ << " " << info.target_path.value()
               << " != " << expected_path.value();
     return false;
   }
   if (info.url_chain.size() != 1u) {
     DVLOG(20) << __FUNCTION__ << " " << info.url_chain.size() << " != 1";
@@ skipping 507 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SavePageAsMHTMLBrowserTest);
 };
 
 SavePageAsMHTMLBrowserTest::~SavePageAsMHTMLBrowserTest() {
 }
 
 IN_PROC_BROWSER_TEST_F(SavePageAsMHTMLBrowserTest, SavePageAsMHTML) {
-  static const int64 kFileSizeMin = 2758;
+  static const int64_t kFileSizeMin = 2758;
   GURL url = NavigateToMockURL("b");
   base::FilePath download_dir = DownloadPrefs::FromDownloadManager(
       GetDownloadManager())->DownloadPath();
   base::FilePath full_file_name = download_dir.AppendASCII(std::string(
       "Test page for saving page feature.mhtml"));
   SavePackageFilePicker::SetShouldPromptUser(false);
   DownloadPersistedObserver persisted(browser()->profile(), base::Bind(
       &DownloadStoredProperly, url, full_file_name, -1,
       history::DownloadState::COMPLETE));
   scoped_refptr<content::MessageLoopRunner> loop_runner(
       new content::MessageLoopRunner);
   SavePackageFinishedObserver observer(
       content::BrowserContext::GetDownloadManager(browser()->profile()),
       loop_runner->QuitClosure());
   chrome::SavePage(browser());
   loop_runner->Run();
   ASSERT_TRUE(VerifySavePackageExpectations(browser(), url));
   persisted.WaitForPersisted();
 
   ASSERT_TRUE(base::PathExists(full_file_name));
-  int64 actual_file_size = -1;
+  int64_t actual_file_size = -1;
   EXPECT_TRUE(base::GetFileSize(full_file_name, &actual_file_size));
   EXPECT_LE(kFileSizeMin, actual_file_size);
 }
 
 IN_PROC_BROWSER_TEST_F(SavePageBrowserTest, SavePageBrowserTest_NonMHTML) {
   SavePackageFilePicker::SetShouldPromptUser(false);
   GURL url("data:text/plain,foo");
   ui_test_utils::NavigateToURL(browser(), url);
   scoped_refptr<content::MessageLoopRunner> loop_runner(
       new content::MessageLoopRunner);
@@ skipping 84 matching lines @@
   base::FilePath expected_files[] = {
       full_file_name,
       dir.AppendASCII("a.html"),  // From iframes.htm
       dir.AppendASCII("b.html"),  // From iframes.htm
       dir.AppendASCII("1.css"),   // From b.htm
       dir.AppendASCII("1.png"),   // Deduplicated from iframes.htm and b.htm.
   };
   for (auto file_path : expected_files) {
     EXPECT_TRUE(base::PathExists(file_path)) << "Does " << file_path.value()
                                              << " exist?";
-    int64 actual_file_size = 0;
+    int64_t actual_file_size = 0;
     EXPECT_TRUE(base::GetFileSize(file_path, &actual_file_size));
     EXPECT_NE(0, actual_file_size) << "Is " << file_path.value()
                                    << " non-empty?";
   }
 
   // Verify that local links got correctly replaced with local paths
   // (most importantly for iframe elements, which are only exercised
   // by this particular test).
   std::string main_contents;
   ASSERT_TRUE(base::ReadFileToString(full_file_name, &main_contents));
@@ skipping 351 matching lines @@
   TestMultiFramePage(save_page_type, url, 6, expected_substrings);
 }
 
 INSTANTIATE_TEST_CASE_P(
     SaveType,
     SavePageMultiFrameBrowserTest,
     ::testing::Values(content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML,
                       content::SAVE_PAGE_TYPE_AS_MHTML));
 
 }  // namespace