[Offline Pages] Adds Rappor metrics measuring what domains are saved & viewed.

components/offline_pages/offline_page_model.cc

 // Copyright 2015 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.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/weak_ptr.h"

[fgorski, 2016/05/13 17:49:18]

this is already in .h file.

 #include "base/metrics/histogram_macros.h"
 #include "base/optional.h"
 #include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/offline_pages/client_policy_controller.h"
 #include "components/offline_pages/offline_page_item.h"
 #include "components/offline_pages/offline_page_storage_manager.h"
 #include "components/offline_pages/proto/offline_pages.pb.h"
+#include "components/rappor/rappor_service.h"
+#include "components/rappor/rappor_utils.h"
 #include "url/gurl.h"
 
 using ArchiverResult = offline_pages::OfflinePageArchiver::ArchiverResult;
 using SavePageResult = offline_pages::OfflinePageModel::SavePageResult;
 
 namespace offline_pages {
 
 namespace {
 
 // This enum is used in an UMA histogram. Hence the entries here shouldn't
@@ skipping 63 matching lines @@
         base::DirectoryExists(id_path.second)) {
       ids_of_pages_missing_archive_file->push_back(id_path.first);
     }
   }
 }
 
 void EnsureArchivesDirCreated(const base::FilePath& archives_dir) {
   CHECK(base::CreateDirectory(archives_dir));
 }
 
+// Record a sample for the OfflinePages.SavedPage rappor metric.
+void SampleOfflinePageURL(
+    const GURL& url,
+    const base::WeakPtr<rappor::RapporService>& rappor_service) {
+  if (rappor_service && url.is_valid()) {
+    rappor::SampleDomainAndRegistryFromGURL(rappor_service.get(),
+                                            "OfflinePages.SavedPage", url);
+  }
+}
+
 }  // namespace
 
 // static
 bool OfflinePageModel::CanSavePage(const GURL& url) {
   return url.SchemeIsHTTPOrHTTPS();
 }
 
 // protected
 OfflinePageModel::OfflinePageModel()
     : is_loaded_(false), weak_ptr_factory_(this) {}
 
 OfflinePageModel::OfflinePageModel(
     std::unique_ptr<OfflinePageMetadataStore> store,
     const base::FilePath& archives_dir,
+    base::WeakPtr<rappor::RapporService> rappor_service,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : store_(std::move(store)),
       archives_dir_(archives_dir),
       is_loaded_(false),
       task_runner_(task_runner),
       policy_controller_(new ClientPolicyController()),
       storage_manager_(new OfflinePageStorageManager(this)),
+      rappor_service_(rappor_service),
       weak_ptr_factory_(this) {
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(EnsureArchivesDirCreated, archives_dir_),
       base::Bind(&OfflinePageModel::OnEnsureArchivesDirCreatedDone,
                  weak_ptr_factory_.GetWeakPtr(), base::TimeTicks::Now()));
 }
 
 OfflinePageModel::~OfflinePageModel() {
 }
 
@@ skipping 13 matching lines @@
 
   // Skip saving the page that is not intended to be saved, like local file
   // page.
   if (!CanSavePage(url)) {
     InformSavePageDone(callback, SavePageResult::SKIPPED, kInvalidOfflineId);
     return;
   }
 
   DCHECK(archiver.get());
 
+  SampleOfflinePageURL(url, rappor_service_);
+
   int64_t offline_id = GenerateOfflineId();
 
   archiver->CreateArchive(
       archives_dir_,
       offline_id,
       base::Bind(&OfflinePageModel::OnCreateArchiveDone,
                  weak_ptr_factory_.GetWeakPtr(), url, offline_id,
                  client_id, base::Time::Now(), callback));
   pending_archivers_.push_back(std::move(archiver));
 }
@@ skipping 637 matching lines @@
 void OfflinePageModel::RunWhenLoaded(const base::Closure& task) {
   if (!is_loaded_) {
     delayed_tasks_.push_back(task);
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);
 }
 
 }  // namespace offline_pages