Update offline pages UMAs

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"
@@ skipping 85 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));
 }
 
+std::string AddHistogramSuffix(const ClientId& client_id,
+                               const char* histogram_name) {
+  if (client_id.name_space.empty()) {
+    NOTREACHED();
+    return histogram_name;
+  }
+  std::string adjusted_histogram_name(histogram_name);
+  adjusted_histogram_name += ".";
+  adjusted_histogram_name += client_id.name_space;
+  return adjusted_histogram_name;
+}
+
 }  // namespace
 
 // static
 bool OfflinePageModel::CanSavePage(const GURL& url) {
   return url.SchemeIsHTTPOrHTTPS();
 }
 
 OfflinePageModel::OfflinePageModel(
     std::unique_ptr<OfflinePageMetadataStore> store,
     const base::FilePath& archives_dir,
@@ skipping 21 matching lines @@
 }
 
 void OfflinePageModel::SavePage(const GURL& url,
                                 const ClientId& client_id,
                                 std::unique_ptr<OfflinePageArchiver> archiver,
                                 const SavePageCallback& callback) {
   DCHECK(is_loaded_);
 
   // Skip saving the page that is not intended to be saved, like local file
   // page.
-  if (!CanSavePage(url)) {
-    InformSavePageDone(callback, SavePageResult::SKIPPED, kInvalidOfflineId);
+  if (url.is_valid() && !CanSavePage(url)) {
+    InformSavePageDone(callback, SavePageResult::SKIPPED, client_id,
+                       kInvalidOfflineId);
     return;
   }
 
-  DCHECK(archiver.get());
+  // The web contents is not available if archiver is not created and passed.
+  if (!archiver.get()) {
+    InformSavePageDone(callback, SavePageResult::CONTENT_UNAVAILABLE, client_id,
+                       kInvalidOfflineId);
+    return;
+  }
 
   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));
 }
 
 void OfflinePageModel::MarkPageAccessed(int64_t offline_id) {
   DCHECK(is_loaded_);
   auto iter = offline_pages_.find(offline_id);
   if (iter == offline_pages_.end())
     return;
 
   // 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;
 
   base::Time now = base::Time::Now();
   base::TimeDelta time_since_last_accessed =
       now - offline_page_item.last_access_time;
 
-  // The last access time was set to same as creation time when the page was
-  // created.
-  if (offline_page_item.creation_time == offline_page_item.last_access_time) {
-    UMA_HISTOGRAM_CUSTOM_COUNTS("OfflinePages.FirstOpenSinceCreated",
-                                time_since_last_accessed.InMinutes(), 1,
-                                kMaxOpenedPageHistogramBucket.InMinutes(), 50);
-  } else {
-    UMA_HISTOGRAM_CUSTOM_COUNTS("OfflinePages.OpenSinceLastOpen",
-                                time_since_last_accessed.InMinutes(), 1,
-                                kMaxOpenedPageHistogramBucket.InMinutes(), 50);
-  }
+  // When the access account is still zero, the page is opened for the first
+  // time since its creation.
+  UMA_HISTOGRAM_CUSTOM_COUNTS(
+      AddHistogramSuffix(
+          offline_page_item.client_id,
+          (offline_page_item.access_count == 0) ?
+              "OfflinePages.FirstOpenSinceCreated" :
+              "OfflinePages.OpenSinceLastOpen").c_str(),
+      time_since_last_accessed.InMinutes(), 1,
+      kMaxOpenedPageHistogramBucket.InMinutes(), 50);
 
   offline_page_item.last_access_time = now;
   offline_page_item.access_count++;
 
   store_->AddOrUpdateOfflinePage(
       offline_page_item,
       base::Bind(&OfflinePageModel::OnMarkPageAccesseDone,
                  weak_ptr_factory_.GetWeakPtr(), offline_page_item));
 }
 
@@ skipping 312 matching lines @@
                                            OfflinePageArchiver* archiver,
                                            ArchiverResult archiver_result,
                                            const GURL& url,
                                            const base::FilePath& file_path,
                                            int64_t file_size) {
   if (requested_url != url) {
     DVLOG(1) << "Saved URL does not match requested URL.";
     // TODO(fgorski): We have created an archive for a wrong URL. It should be
     // deleted from here, once archiver has the right functionality.
     InformSavePageDone(callback, SavePageResult::ARCHIVE_CREATION_FAILED,
-                       offline_id);
+                       client_id, offline_id);
     DeletePendingArchiver(archiver);
     return;
   }
 
   if (archiver_result != ArchiverResult::SUCCESSFULLY_CREATED) {
     SavePageResult result = ToSavePageResult(archiver_result);
-    InformSavePageDone(callback, result, offline_id);
+    InformSavePageDone(callback, result, client_id, offline_id);
     DeletePendingArchiver(archiver);
     return;
   }
   OfflinePageItem offline_page_item(url, offline_id, client_id, file_path,
                                     file_size, start_time);
   store_->AddOrUpdateOfflinePage(
       offline_page_item,
       base::Bind(&OfflinePageModel::OnAddOfflinePageDone,
                  weak_ptr_factory_.GetWeakPtr(), archiver, callback,
                  offline_page_item));
 }
 
 void OfflinePageModel::OnAddOfflinePageDone(OfflinePageArchiver* archiver,
                                             const SavePageCallback& callback,
                                             const OfflinePageItem& offline_page,
                                             bool success) {
   SavePageResult result;
   if (success) {
     offline_pages_[offline_page.offline_id] = offline_page;
     result = SavePageResult::SUCCESS;
     UMA_HISTOGRAM_TIMES(
-        "OfflinePages.SavePageTime",
+        AddHistogramSuffix(
+            offline_page.client_id, "OfflinePages.SavePageTime").c_str(),
         base::Time::Now() - offline_page.creation_time);
     UMA_HISTOGRAM_MEMORY_KB(
-        "OfflinePages.PageSize", offline_page.file_size / 1024);
+        AddHistogramSuffix(
+            offline_page.client_id, "OfflinePages.PageSize").c_str(),
+        offline_page.file_size / 1024);
   } else {
     result = SavePageResult::STORE_FAILURE;
   }
-  InformSavePageDone(callback, result, offline_page.offline_id);
+  InformSavePageDone(callback, result, offline_page.client_id,
+                     offline_page.offline_id);
   DeletePendingArchiver(archiver);
 
   FOR_EACH_OBSERVER(Observer, observers_, OfflinePageModelChanged(this));
 }
 
 void OfflinePageModel::OnMarkPageAccesseDone(
     const OfflinePageItem& offline_page_item, bool success) {
   // Update the item in the cache only upon success.
   if (success)
     offline_pages_[offline_page_item.offline_id] = offline_page_item;
@@ skipping 31 matching lines @@
     delayed_task.Run();
   delayed_tasks_.clear();
 
   FOR_EACH_OBSERVER(Observer, observers_, OfflinePageModelLoaded(this));
 
   CheckForExternalFileDeletion();
 }
 
 void OfflinePageModel::InformSavePageDone(const SavePageCallback& callback,
                                           SavePageResult result,
+                                          const ClientId& client_id,
                                           int64_t offline_id) {
   UMA_HISTOGRAM_ENUMERATION(
-      "OfflinePages.SavePageResult",
+      AddHistogramSuffix(client_id, "OfflinePages.SavePageResult").c_str(),
       static_cast<int>(result),
       static_cast<int>(SavePageResult::RESULT_COUNT));
   callback.Run(result, offline_id);
 }
 
 void OfflinePageModel::DeletePendingArchiver(OfflinePageArchiver* archiver) {
   pending_archivers_.erase(std::find(
       pending_archivers_.begin(), pending_archivers_.end(), archiver));
 }
 
@@ skipping 20 matching lines @@
     bool success) {
   // Delete the offline page from the in memory cache regardless of success in
   // store.
   base::Time now = base::Time::Now();
   int64_t total_size = 0;
   for (int64_t offline_id : offline_ids) {
     auto iter = offline_pages_.find(offline_id);
     if (iter == offline_pages_.end())
       continue;
     total_size += iter->second.file_size;
+    ClientId client_id = iter->second.client_id;
     UMA_HISTOGRAM_CUSTOM_COUNTS(
-        "OfflinePages.PageLifetime",
+        AddHistogramSuffix(client_id, "OfflinePages.PageLifetime").c_str(),
         (now - iter->second.creation_time).InMinutes(),
         1,
         base::TimeDelta::FromDays(365).InMinutes(),
         100);
     UMA_HISTOGRAM_CUSTOM_COUNTS(
-        "OfflinePages.DeletePage.TimeSinceLastOpen",
+        AddHistogramSuffix(
+            client_id, "OfflinePages.DeletePage.TimeSinceLastOpen").c_str(),
         (now - iter->second.last_access_time).InMinutes(),
         1,
         base::TimeDelta::FromDays(365).InMinutes(),
         100);
     UMA_HISTOGRAM_CUSTOM_COUNTS(
-        "OfflinePages.DeletePage.LastOpenToCreated",
+        AddHistogramSuffix(
+            client_id, "OfflinePages.DeletePage.LastOpenToCreated").c_str(),
         (iter->second.last_access_time - iter->second.creation_time).
             InMinutes(),
         1,
         base::TimeDelta::FromDays(365).InMinutes(),
         100);
     UMA_HISTOGRAM_MEMORY_KB(
-        "OfflinePages.DeletePage.PageSize", iter->second.file_size / 1024);
+        AddHistogramSuffix(
+            client_id, "OfflinePages.DeletePage.PageSize").c_str(),
+        iter->second.file_size / 1024);
     UMA_HISTOGRAM_COUNTS(
-        "OfflinePages.DeletePage.AccessCount", iter->second.access_count);
+        AddHistogramSuffix(
+            client_id, "OfflinePages.DeletePage.AccessCount").c_str(),
+        iter->second.access_count);
     FOR_EACH_OBSERVER(
         Observer, observers_,
         OfflinePageDeleted(iter->second.offline_id, iter->second.client_id));
     offline_pages_.erase(iter);
   }
   if (offline_ids.size() > 1) {
     UMA_HISTOGRAM_COUNTS("OfflinePages.BatchDelete.Count", offline_ids.size());
     UMA_HISTOGRAM_MEMORY_KB(
         "OfflinePages.BatchDelete.TotalPageSize", total_size / 1024);
   }
@@ skipping 103 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