add a couple of casts.

components/offline_pages/offline_page_storage_manager.cc

 // Copyright 2016 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/offline_pages/offline_page_storage_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/time/clock.h"
@@ skipping 48 matching lines @@
                                   stats));
 }
 
 void OfflinePageStorageManager::OnGetAllPagesDone(
     const ClearPagesCallback& callback,
     const ArchiveManager::StorageStats& stats,
     const MultipleOfflinePageItemResult& pages) {
   std::vector<int64_t> offline_ids;
   GetExpiredPageIds(pages, stats, offline_ids);
   client_->DeletePagesByOfflineId(
-      offline_ids,
-      base::Bind(&OfflinePageStorageManager::OnExpiredPagesDeleted,
-                 weak_ptr_factory_.GetWeakPtr(), callback, offline_ids.size()));
+      offline_ids, base::Bind(&OfflinePageStorageManager::OnExpiredPagesDeleted,
+                              weak_ptr_factory_.GetWeakPtr(), callback,
+                              static_cast<int>(offline_ids.size())));
 }
 
 void OfflinePageStorageManager::OnExpiredPagesDeleted(
     const ClearPagesCallback& callback,
     int pages_cleared,
     DeletePageResult result) {
   last_clear_time_ = clock_->Now();
   ClearStorageResult clear_result = result == DeletePageResult::SUCCESS
                                         ? ClearStorageResult::SUCCESS
                                         : ClearStorageResult::DELETE_FAILURE;
@@ skipping 23 matching lines @@
     std::vector<OfflinePageItem>& page_list = iter.second;
 
     LifetimePolicy policy =
         policy_controller_->GetPolicy(name_space).lifetime_policy;
 
     std::sort(page_list.begin(), page_list.end(),
               [](const OfflinePageItem& a, const OfflinePageItem& b) -> bool {
                 return a.last_access_time > b.last_access_time;
               });
 
-    int page_list_size = page_list.size();
+    int page_list_size = static_cast<int>(page_list.size());
     int pos = 0;
     while (pos < page_list_size &&
            (policy.page_limit == kUnlimitedPages || pos < policy.page_limit) &&
            !ShouldBeExpired(now, page_list.at(pos))) {
       kept_pages_size += page_list.at(pos).file_size;
       kept_pages.push_back(page_list.at(pos));
       pos++;
     }
 
     for (; pos < page_list_size; pos++)
       offline_ids.push_back(page_list.at(pos).offline_id);
   }
 
   // If we're still over the clear threshold, we're going to clear remaining
   // pages from oldest last access time.
   int64_t free_space = stats.free_disk_space;
   int64_t total_size = stats.total_archives_size;
   int64_t space_to_release =
       kept_pages_size -
       (total_size + free_space) * kOfflinePageStorageClearThreshold;
   if (space_to_release > 0) {
     // Here we're sorting the |kept_pages| with oldest first.
     std::sort(kept_pages.begin(), kept_pages.end(),
               [](const OfflinePageItem& a, const OfflinePageItem& b) -> bool {
                 return a.last_access_time < b.last_access_time;
               });
-    int kept_pages_size = kept_pages.size();
+    int kept_pages_size = static_cast<int>(kept_pages.size());
     int pos = 0;
     while (pos < kept_pages_size && space_to_release > 0) {
       space_to_release -= kept_pages.at(pos).file_size;
       offline_ids.push_back(kept_pages.at(pos).offline_id);
       pos++;
     }
   }
 }
 
 OfflinePageStorageManager::ClearMode
@@ skipping 21 matching lines @@
 }
 
 bool OfflinePageStorageManager::ShouldBeExpired(const base::Time& now,
                                                 const OfflinePageItem& page) {
   const LifetimePolicy& policy =
       policy_controller_->GetPolicy(page.client_id.name_space).lifetime_policy;
   return now - page.last_access_time >= policy.expiration_period;
 }
 
 }  // namespace offline_pages