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

components/history/core/browser/download_database.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 "components/history/core/browser/download_database.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
@@ skipping 212 matching lines @@
     return EnsureColumnExists("end_time", "INTEGER NOT NULL DEFAULT 0") &&
            EnsureColumnExists("opened", "INTEGER NOT NULL DEFAULT 0");
   } else {
     // If the "downloads" table doesn't exist, the downloads_url_chain
     // table better not.
     return (!GetDB().DoesTableExist("downloads_url_chain") &&
             GetDB().Execute(kSchema) && GetDB().Execute(kUrlChainSchema));
   }
 }
 
-uint32 DownloadDatabase::GetNextDownloadId() {
+uint32_t DownloadDatabase::GetNextDownloadId() {
   sql::Statement select_max_id(GetDB().GetUniqueStatement(
       "SELECT max(id) FROM downloads"));
   bool result = select_max_id.Step();
   DCHECK(result);
   // If there are zero records in the downloads table, then max(id) will
   // return 0 = kInvalidDownloadId, so GetNextDownloadId() will set
   // *id = kInvalidDownloadId + 1.
   //
   // If there is at least one record but all of the |id|s are
   // <= kInvalidDownloadId, then max(id) will return <= kInvalidDownloadId,
   // so GetNextDownloadId() should return kInvalidDownloadId + 1.
   //
   // Note that any records with |id <= kInvalidDownloadId| will be dropped in
   // QueryDownloads().
   //
   // SQLITE doesn't have unsigned integers.
-  return 1 + static_cast<uint32>(std::max(
-      static_cast<int64>(kInvalidDownloadId),
-      select_max_id.ColumnInt64(0)));
+  return 1 + static_cast<uint32_t>(
+                 std::max(static_cast<int64_t>(kInvalidDownloadId),
+                          select_max_id.ColumnInt64(0)));
 }
 
 bool DownloadDatabase::DropDownloadTable() {
   return GetDB().Execute("DROP TABLE downloads");
 }
 
 void DownloadDatabase::QueryDownloads(std::vector<DownloadRow>* results) {
   EnsureInProgressEntriesCleanedUp();
 
   results->clear();
-  std::set<uint32> ids;
+  std::set<uint32_t> ids;
 
-  std::map<uint32, DownloadRow*> info_map;
+  std::map<uint32_t, DownloadRow*> info_map;
 
   sql::Statement statement_main(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "SELECT id, current_path, target_path, "
       "mime_type, original_mime_type, "
       "start_time, received_bytes, "
       "total_bytes, state, danger_type, interrupt_reason, end_time, opened, "
       "referrer, by_ext_id, by_ext_name, etag, last_modified "
       "FROM downloads ORDER BY start_time"));
 
   while (statement_main.Step()) {
     scoped_ptr<DownloadRow> info(new DownloadRow());
     int column = 0;
 
     // SQLITE does not have unsigned integers, so explicitly handle negative
     // |id|s instead of casting them to very large uint32s, which would break
     // the max(id) logic in GetNextDownloadId().
-    int64 signed_id = statement_main.ColumnInt64(column++);
+    int64_t signed_id = statement_main.ColumnInt64(column++);
     info->id = IntToDownloadId(signed_id);
     info->current_path = ColumnFilePath(statement_main, column++);
     info->target_path = ColumnFilePath(statement_main, column++);
     info->mime_type = statement_main.ColumnString(column++);
     info->original_mime_type = statement_main.ColumnString(column++);
     info->start_time =
         base::Time::FromInternalValue(statement_main.ColumnInt64(column++));
     info->received_bytes = statement_main.ColumnInt64(column++);
     info->total_bytes = statement_main.ColumnInt64(column++);
     int state = statement_main.ColumnInt(column++);
     info->state = IntToDownloadState(state);
     if (info->state == DownloadState::INVALID)
       UMA_HISTOGRAM_COUNTS("Download.DatabaseInvalidState", state);
     info->danger_type =
         IntToDownloadDangerType(statement_main.ColumnInt(column++));
     info->interrupt_reason =
         IntToDownloadInterruptReason(statement_main.ColumnInt(column++));
     info->end_time =
         base::Time::FromInternalValue(statement_main.ColumnInt64(column++));
     info->opened = statement_main.ColumnInt(column++) != 0;
     info->referrer_url = GURL(statement_main.ColumnString(column++));
     info->by_ext_id = statement_main.ColumnString(column++);
     info->by_ext_name = statement_main.ColumnString(column++);
     info->etag = statement_main.ColumnString(column++);
     info->last_modified = statement_main.ColumnString(column++);
 
     // If the record is corrupted, note that and drop it.
     // http://crbug.com/251269
     DroppedReason dropped_reason = DROPPED_REASON_MAX;
-    if (signed_id <= static_cast<int64>(kInvalidDownloadId)) {
+    if (signed_id <= static_cast<int64_t>(kInvalidDownloadId)) {
       // SQLITE doesn't have unsigned integers.
       dropped_reason = DROPPED_REASON_BAD_ID;
     } else if (!ids.insert(info->id).second) {
       dropped_reason = DROPPED_REASON_DUPLICATE_ID;
       NOTREACHED() << info->id;
     } else if (info->state == DownloadState::INVALID) {
       dropped_reason = DROPPED_REASON_BAD_STATE;
     } else if (info->danger_type == DownloadDangerType::INVALID) {
       dropped_reason = DROPPED_REASON_BAD_DANGER_TYPE;
     }
     if (dropped_reason != DROPPED_REASON_MAX) {
       UMA_HISTOGRAM_ENUMERATION("Download.DatabaseRecordDropped",
                                 dropped_reason,
                                 DROPPED_REASON_MAX + 1);
     } else {
       DCHECK(!ContainsKey(info_map, info->id));
-      uint32 id = info->id;
+      uint32_t id = info->id;
       info_map[id] = info.release();
     }
   }
 
   sql::Statement statement_chain(GetDB().GetCachedStatement(
       SQL_FROM_HERE,
       "SELECT id, chain_index, url FROM downloads_url_chains "
       "ORDER BY id, chain_index"));
 
   while (statement_chain.Step()) {
     int column = 0;
     // See the comment above about SQLITE lacking unsigned integers.
-    int64 signed_id = statement_chain.ColumnInt64(column++);
+    int64_t signed_id = statement_chain.ColumnInt64(column++);
     int chain_index = statement_chain.ColumnInt(column++);
 
-    if (signed_id <= static_cast<int64>(kInvalidDownloadId))
+    if (signed_id <= static_cast<int64_t>(kInvalidDownloadId))
       continue;
-    uint32 id = IntToDownloadId(signed_id);
+    uint32_t id = IntToDownloadId(signed_id);
 
     // Note that these DCHECKs may trip as a result of corrupted databases.
     // We have them because in debug builds the chances are higher there's
     // an actual bug than that the database is corrupt, but we handle the
     // DB corruption case in production code.
 
     // Confirm the id has already been seen--if it hasn't, discard the
     // record.
     DCHECK(ContainsKey(info_map, id));
     if (!ContainsKey(info_map, id))
       continue;
 
     // Confirm all previous URLs in the chain have already been seen;
     // if not, fill in with null or discard record.
     int current_chain_size = static_cast<int>(info_map[id]->url_chain.size());
     std::vector<GURL>* url_chain(&info_map[id]->url_chain);
     DCHECK_EQ(chain_index, current_chain_size);
     while (current_chain_size < chain_index) {
       url_chain->push_back(GURL());
       current_chain_size++;
     }
     if (current_chain_size > chain_index)
       continue;
 
     // Save the record.
     url_chain->push_back(GURL(statement_chain.ColumnString(2)));
   }
 
-  for (std::map<uint32, DownloadRow*>::iterator
-           it = info_map.begin(); it != info_map.end(); ++it) {
+  for (std::map<uint32_t, DownloadRow*>::iterator it = info_map.begin();
+       it != info_map.end(); ++it) {
     DownloadRow* row = it->second;
     bool empty_url_chain = row->url_chain.empty();
     UMA_HISTOGRAM_BOOLEAN("Download.DatabaseEmptyUrlChain", empty_url_chain);
     if (empty_url_chain) {
       RemoveDownload(row->id);
     } else {
       // Copy the contents of the stored info.
       results->push_back(*row);
     }
     delete row;
@@ skipping 146 matching lines @@
       UMA_HISTOGRAM_ENUMERATION("Download.DatabaseURLChainInsertError",
                                 GetDB().GetErrorCode() & 0xff, 50);
       RemoveDownload(info.id);
       return false;
     }
     statement_insert_chain.Reset(true);
   }
   return true;
 }
 
-void DownloadDatabase::RemoveDownload(uint32 id) {
+void DownloadDatabase::RemoveDownload(uint32_t id) {
   EnsureInProgressEntriesCleanedUp();
 
   sql::Statement downloads_statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM downloads WHERE id=?"));
   downloads_statement.BindInt(0, id);
   if (!downloads_statement.Run()) {
     UMA_HISTOGRAM_ENUMERATION("Download.DatabaseMainDeleteError",
                               GetDB().GetErrorCode() & 0xff, 50);
     return;
   }
   RemoveDownloadURLs(id);
 }
 
-void DownloadDatabase::RemoveDownloadURLs(uint32 id) {
+void DownloadDatabase::RemoveDownloadURLs(uint32_t id) {
   sql::Statement urlchain_statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM downloads_url_chains WHERE id=?"));
   urlchain_statement.BindInt(0, id);
   if (!urlchain_statement.Run()) {
     UMA_HISTOGRAM_ENUMERATION("Download.DatabaseURLChainDeleteError",
                               GetDB().GetErrorCode() & 0xff, 50);
   }
 }
 
 size_t DownloadDatabase::CountDownloads() {
   EnsureInProgressEntriesCleanedUp();
 
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "SELECT count(*) from downloads"));
   statement.Step();
   return statement.ColumnInt(0);
 }
 
 }  // namespace history