Move const double data out of header file

components/offline_pages/offline_page_storage_manager_unittest.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 <stdint.h>
 #include <map>
 #include <vector>
 
@@ skipping 334 matching lines @@
   Initialize(std::vector<PageSettings>(
       {{kBookmarkNamespace, 10, 10}, {kLastNNamespace, 10, 10}}));
   clock()->Advance(base::TimeDelta::FromMinutes(30));
   TryClearPages();
   EXPECT_EQ(20, last_cleared_page_count());
   EXPECT_EQ(1, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   EXPECT_EQ(0, static_cast<int>(model()->GetRemovedPages().size()));
 
   // Advance clock so we go over the gap, but no expired pages.
-  clock()->Advance(kClearStorageInterval + base::TimeDelta::FromMinutes(1));
+  clock()->Advance(constants::kClearStorageInterval +
+                   base::TimeDelta::FromMinutes(1));
   TryClearPages();
   EXPECT_EQ(0, last_cleared_page_count());
   EXPECT_EQ(2, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   EXPECT_EQ(0, static_cast<int>(model()->GetRemovedPages().size()));
 
   // Advance clock so we are still in the gap, should be unnecessary.
-  clock()->Advance(kClearStorageInterval - base::TimeDelta::FromMinutes(1));
+  clock()->Advance(constants::kClearStorageInterval -
+                   base::TimeDelta::FromMinutes(1));
   TryClearPages();
   EXPECT_EQ(0, last_cleared_page_count());
   EXPECT_EQ(3, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::UNNECESSARY, last_clear_storage_result());
   EXPECT_EQ(0, static_cast<int>(model()->GetRemovedPages().size()));
 }
 
 TEST_F(OfflinePageStorageManagerTest, TestTwoStepExpiration) {
   Initialize(std::vector<PageSettings>({{kBookmarkNamespace, 10, 10}}));
   clock()->Advance(base::TimeDelta::FromMinutes(30));
   TryClearPages();
   EXPECT_EQ(10, last_cleared_page_count());
   EXPECT_EQ(1, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   EXPECT_EQ(0, static_cast<int>(model()->GetRemovedPages().size()));
 
-  clock()->Advance(kRemovePageItemInterval + base::TimeDelta::FromDays(1));
+  clock()->Advance(constants::kRemovePageItemInterval +
+                   base::TimeDelta::FromDays(1));
   TryClearPages();
   EXPECT_EQ(10, last_cleared_page_count());
   EXPECT_EQ(2, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   EXPECT_EQ(10, static_cast<int>(model()->GetRemovedPages().size()));
 }
 
 TEST_F(OfflinePageStorageManagerTest, TestClearMultipleTimes) {
   Initialize(std::vector<PageSettings>({{kBookmarkNamespace, 30, 0},
                                         {kLastNNamespace, 100, 1},
@@ skipping 25 matching lines @@
   EXPECT_EQ(3, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::UNNECESSARY, last_clear_storage_result());
   EXPECT_EQ(0, static_cast<int>(model()->GetRemovedPages().size()));
 
   // Adding more fresh pages to make it go over limit.
   clock()->Advance(base::TimeDelta::FromMinutes(5));
   model()->AddPages({kBookmarkNamespace, 400, 0});
   int64_t total_size_before = model()->GetTotalSize();
   int64_t available_space = 300 * (1 << 20);  // 300 MB
   test_archive_manager()->SetValues({available_space, total_size_before});
-  EXPECT_GE(total_size_before,
-            kOfflinePageStorageLimit * (available_space + total_size_before));
+  EXPECT_GE(total_size_before, constants::kOfflinePageStorageLimit *
+                                   (available_space + total_size_before));
   TryClearPages();
-  EXPECT_LE(total_size_before * kOfflinePageStorageClearThreshold,
+  EXPECT_LE(total_size_before * constants::kOfflinePageStorageClearThreshold,
             model()->GetTotalSize());
   EXPECT_EQ(4, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   EXPECT_EQ(0, static_cast<int>(model()->GetRemovedPages().size()));
   int expired_page_count = last_cleared_page_count();
 
   // After more days, all pages should be expired and .
-  clock()->Advance(kRemovePageItemInterval + base::TimeDelta::FromDays(1));
+  clock()->Advance(constants::kRemovePageItemInterval +
+                   base::TimeDelta::FromDays(1));
   TryClearPages();
   EXPECT_EQ(0, model()->GetTotalSize());
   EXPECT_EQ(5, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   // Number of removed pages should be the ones expired above and all the pages
   // initially created for last_n namespace.
   EXPECT_EQ(expired_page_count + 101,
             static_cast<int>(model()->GetRemovedPages().size()));
 }
 
 }  // namespace offline_pages