Move all components/offline_pages/ files into component/offline_pages/core

components/offline_pages/core/offline_page_model_impl.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_model_impl.h"
+#include "components/offline_pages/core/offline_page_model_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
-#include "components/offline_pages/archive_manager.h"
-#include "components/offline_pages/client_namespace_constants.h"
-#include "components/offline_pages/client_policy_controller.h"
-#include "components/offline_pages/offline_page_item.h"
-#include "components/offline_pages/offline_page_model_query.h"
-#include "components/offline_pages/offline_page_storage_manager.h"
+#include "components/offline_pages/core/archive_manager.h"
+#include "components/offline_pages/core/client_namespace_constants.h"
+#include "components/offline_pages/core/client_policy_controller.h"
+#include "components/offline_pages/core/offline_page_item.h"
+#include "components/offline_pages/core/offline_page_model_query.h"
+#include "components/offline_pages/core/offline_page_storage_manager.h"
 #include "url/gurl.h"
 
 using ArchiverResult = offline_pages::OfflinePageArchiver::ArchiverResult;
 using ClearStorageCallback =
     offline_pages::OfflinePageStorageManager::ClearStorageCallback;
 using ClearStorageResult =
     offline_pages::OfflinePageStorageManager::ClearStorageResult;
 
 namespace offline_pages {
 
@@ skipping 83 matching lines @@
         1.0 * storage_stats.total_archives_size /
         (storage_stats.total_archives_size + storage_stats.free_disk_space) *
         100);
     UMA_HISTOGRAM_PERCENTAGE(
         "OfflinePages.DeletePage.TotalPageSizeAsPercentageOfFreeSpace",
         percentage_of_free);
   }
 }
 
 void ReportSavePageResultHistogramAfterSave(const ClientId& client_id,
-                                           SavePageResult result) {
+                                            SavePageResult result) {
   // The histogram below is an expansion of the UMA_HISTOGRAM_ENUMERATION
   // macro adapted to allow for a dynamically suffixed histogram name.
   // Note: The factory creates and owns the histogram.
   base::HistogramBase* histogram = base::LinearHistogram::FactoryGet(
-      AddHistogramSuffix(client_id, "OfflinePages.SavePageResult"),
-      1,
+      AddHistogramSuffix(client_id, "OfflinePages.SavePageResult"), 1,
       static_cast<int>(SavePageResult::RESULT_COUNT),
       static_cast<int>(SavePageResult::RESULT_COUNT) + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(static_cast<int>(result));
 }
 
 // Goes through the list of offline pages, compiling the following two metrics:
 //   - a count of the pages with the same URL
 //   - The difference between the |created_before| time and the creation time of
 //     the page with the closest creation time before |created_before|.
@@ skipping 45 matching lines @@
       AddHistogramSuffix(offline_page.client_id, "OfflinePages.SavePageTime"),
       base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromSeconds(10),
       50, base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->AddTime(save_time - offline_page.creation_time);
 
   // The histogram below is an expansion of the UMA_HISTOGRAM_CUSTOM_COUNTS
   // macro adapted to allow for a dynamically suffixed histogram name.
   // Note: The factory creates and owns the histogram.
   // Reported as Kb between 1Kb and 10Mb.
   histogram = base::Histogram::FactoryGet(
-      AddHistogramSuffix(offline_page.client_id, "OfflinePages.PageSize"),
-      1, 10000, 50, base::HistogramBase::kUmaTargetedHistogramFlag);
+      AddHistogramSuffix(offline_page.client_id, "OfflinePages.PageSize"), 1,
+      10000, 50, base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(offline_page.file_size / 1024);
 
   if (offline_page.client_id.name_space == kDownloadNamespace) {
     int matching_url_count;
     base::TimeDelta time_since_most_recent_duplicate;
     if (GetMatchingURLCountAndMostRecentCreationTime(
             offline_pages, offline_page.client_id.name_space, offline_page.url,
             offline_page.creation_time, &matching_url_count,
             &time_since_most_recent_duplicate)) {
       // Using CUSTOM_COUNTS instead of time-oriented histogram to record
@@ skipping 27 matching lines @@
           &remaining_pages_with_url, nullptr);
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "OfflinePages.DownloadDeletedPageDuplicateCount",
           remaining_pages_with_url, 1, 20, 10);
     }
 
     // The histograms below are an expansion of the UMA_HISTOGRAM_CUSTOM_COUNTS
     // macro adapted to allow for a dynamically suffixed histogram name.
     // Note: The factory creates and owns the histogram.
     base::HistogramBase* histogram = base::Histogram::FactoryGet(
-        AddHistogramSuffix(client_id, "OfflinePages.PageLifetime"),
-        1, max_minutes, 100, base::HistogramBase::kUmaTargetedHistogramFlag);
+        AddHistogramSuffix(client_id, "OfflinePages.PageLifetime"), 1,
+        max_minutes, 100, base::HistogramBase::kUmaTargetedHistogramFlag);
     histogram->Add((delete_time - page.creation_time).InMinutes());
 
     histogram = base::Histogram::FactoryGet(
-        AddHistogramSuffix(
-            client_id, "OfflinePages.DeletePage.TimeSinceLastOpen"),
+        AddHistogramSuffix(client_id,
+                           "OfflinePages.DeletePage.TimeSinceLastOpen"),
         1, max_minutes, 100, base::HistogramBase::kUmaTargetedHistogramFlag);
     histogram->Add((delete_time - page.last_access_time).InMinutes());
 
     histogram = base::Histogram::FactoryGet(
-        AddHistogramSuffix(
-            client_id, "OfflinePages.DeletePage.LastOpenToCreated"),
+        AddHistogramSuffix(client_id,
+                           "OfflinePages.DeletePage.LastOpenToCreated"),
         1, max_minutes, 100, base::HistogramBase::kUmaTargetedHistogramFlag);
     histogram->Add((page.last_access_time - page.creation_time).InMinutes());
 
     // Reported as Kb between 1Kb and 10Mb.
     histogram = base::Histogram::FactoryGet(
-        AddHistogramSuffix(client_id, "OfflinePages.DeletePage.PageSize"),
-        1, 10000, 50, base::HistogramBase::kUmaTargetedHistogramFlag);
+        AddHistogramSuffix(client_id, "OfflinePages.DeletePage.PageSize"), 1,
+        10000, 50, base::HistogramBase::kUmaTargetedHistogramFlag);
     histogram->Add(page.file_size / 1024);
 
     histogram = base::Histogram::FactoryGet(
-        AddHistogramSuffix(client_id, "OfflinePages.DeletePage.AccessCount"),
-        1, 1000000, 50, base::HistogramBase::kUmaTargetedHistogramFlag);
+        AddHistogramSuffix(client_id, "OfflinePages.DeletePage.AccessCount"), 1,
+        1000000, 50, base::HistogramBase::kUmaTargetedHistogramFlag);
     histogram->Add(page.access_count);
   }
 
   if (deleted_pages.size() > 1) {
     UMA_HISTOGRAM_COUNTS("OfflinePages.BatchDelete.Count",
                          static_cast<int32_t>(deleted_pages.size()));
-    UMA_HISTOGRAM_MEMORY_KB(
-        "OfflinePages.BatchDelete.TotalPageSize", total_size / 1024);
+    UMA_HISTOGRAM_MEMORY_KB("OfflinePages.BatchDelete.TotalPageSize",
+                            total_size / 1024);
   }
 }
 
 void ReportPageHistogramsAfterAccess(const OfflinePageItem& offline_page_item,
                                      const base::Time& access_time) {
   // The histogram below is an expansion of the UMA_HISTOGRAM_CUSTOM_COUNTS
   // macro adapted to allow for a dynamically suffixed histogram name.
   // Note: The factory creates and owns the histogram.
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
-        AddHistogramSuffix(
-            offline_page_item.client_id,
-            offline_page_item.access_count == 0 ?
-                "OfflinePages.FirstOpenSinceCreated" :
-                "OfflinePages.OpenSinceLastOpen"),
-        1, kMaxOpenedPageHistogramBucket.InMinutes(), 50,
-        base::HistogramBase::kUmaTargetedHistogramFlag);
+      AddHistogramSuffix(offline_page_item.client_id,
+                         offline_page_item.access_count == 0
+                             ? "OfflinePages.FirstOpenSinceCreated"
+                             : "OfflinePages.OpenSinceLastOpen"),
+      1, kMaxOpenedPageHistogramBucket.InMinutes(), 50,
+      base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(
       (access_time - offline_page_item.last_access_time).InMinutes());
 }
 
 }  // namespace
 
 // protected
 OfflinePageModelImpl::OfflinePageModelImpl()
     : OfflinePageModel(), is_loaded_(false), weak_ptr_factory_(this) {}
 
@@ skipping 71 matching lines @@
 
   // Make a copy of the cached item and update it. The cached item should only
   // be updated upon the successful store operation.
   OfflinePageItem offline_page_item = iter->second;
 
   ReportPageHistogramsAfterAccess(offline_page_item, GetCurrentTime());
 
   offline_page_item.last_access_time = GetCurrentTime();
   offline_page_item.access_count++;
 
-  std::vector<OfflinePageItem> items = { offline_page_item };
+  std::vector<OfflinePageItem> items = {offline_page_item};
   store_->UpdateOfflinePages(
       items, base::Bind(&OfflinePageModelImpl::OnMarkPageAccesseDone,
                         weak_ptr_factory_.GetWeakPtr(), offline_page_item));
 }
 
 void OfflinePageModelImpl::DeletePagesByOfflineId(
     const std::vector<int64_t>& offline_ids,
     const DeletePageCallback& callback) {
   RunWhenLoaded(base::Bind(&OfflinePageModelImpl::DoDeletePagesByOfflineId,
                            weak_ptr_factory_.GetWeakPtr(), offline_ids,
@@ skipping 215 matching lines @@
 
 void OfflinePageModelImpl::GetPagesByOnlineURLWhenLoadDone(
     const GURL& online_url,
     const MultipleOfflinePageItemCallback& callback) const {
   std::vector<OfflinePageItem> result;
 
   GURL::Replacements remove_params;
   remove_params.ClearRef();
 
   GURL online_url_without_fragment =
-        online_url.ReplaceComponents(remove_params);
+      online_url.ReplaceComponents(remove_params);
 
   for (const auto& id_page_pair : offline_pages_) {
     if (id_page_pair.second.IsExpired())
       continue;
     if (online_url == id_page_pair.second.url) {
       result.push_back(id_page_pair.second);
       continue;
     }
     // If the full URL does not match, try with the fragment identifier
     // stripped.
@@ skipping 450 matching lines @@
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);
 }
 
 base::Time OfflinePageModelImpl::GetCurrentTime() const {
   return testing_clock_ ? testing_clock_->Now() : base::Time::Now();
 }
 
 }  // namespace offline_pages