[Offline Pages] Create a event/activity logger

components/offline_pages/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 <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 662 matching lines @@
 }
 
 OfflinePageStorageManager* OfflinePageModelImpl::GetStorageManager() {
   return storage_manager_.get();
 }
 
 bool OfflinePageModelImpl::is_loaded() const {
   return is_loaded_;
 }
 
+void OfflinePageModelImpl::GetLogs(std::vector<std::string>& storage_vector) {

[fgorski, 2016/06/23 16:34:07]

I think a cleaner way would be to expose GetOfflineLogger method.
Please think about that.

[chili, 2016/06/24 02:45:52]

My original thought was that then people can add a bunch of activities to the
logger.  However, that was before I made a bunch of decisions so that the
assumption is no longer true.  Changed.

+  offline_event_logger_.GetLogs(storage_vector);
+}
+
+void OfflinePageModelImpl::SetIsLogging(bool should_log) {
+  offline_event_logger_.SetIsLogging(should_log);
+}
+
 void OfflinePageModelImpl::OnCreateArchiveDone(const GURL& requested_url,
                                                int64_t offline_id,
                                                const ClientId& client_id,
                                                const base::Time& start_time,
                                                const SavePageCallback& callback,
                                                OfflinePageArchiver* archiver,
                                                ArchiverResult archiver_result,
                                                const GURL& url,
                                                const base::FilePath& file_path,
                                                int64_t file_size) {
@@ skipping 24 matching lines @@
 void OfflinePageModelImpl::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;
     ReportPageHistogramAfterSave(offline_page);
+    offline_event_logger_.RecordPageSaved(
+        offline_page.client_id.name_space, offline_page.url.spec(),
+        std::to_string(offline_page.offline_id));
   } else {
     result = SavePageResult::STORE_FAILURE;
   }
   InformSavePageDone(callback, result, offline_page.client_id,
                      offline_page.offline_id);
   DeletePendingArchiver(archiver);
 
   FOR_EACH_OBSERVER(Observer, observers_, OfflinePageModelChanged(this));
 }
 
@@ skipping 89 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(), offline_ids, callback));
 }
 
 void OfflinePageModelImpl::OnRemoveOfflinePagesDone(
     const std::vector<int64_t>& offline_ids,
     const DeletePageCallback& callback,
     bool success) {
   ReportPageHistogramsAfterDelete(offline_pages_, offline_ids);
 
   for (int64_t offline_id : offline_ids) {
+    offline_event_logger_.RecordPageDeleted(std::to_string(offline_id));
     auto iter = offline_pages_.find(offline_id);
     if (iter == offline_pages_.end())
       continue;
     FOR_EACH_OBSERVER(
         Observer, observers_,
         OfflinePageDeleted(iter->second.offline_id, iter->second.client_id));
     offline_pages_.erase(iter);
   }
 
   // Deleting multiple pages always succeeds when it gets to this point.
@@ skipping 79 matching lines @@
     DeletePageResult result) {
   store_->Reset(base::Bind(&OfflinePageModelImpl::OnResetStoreDoneForClearAll,
                            weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void OfflinePageModelImpl::OnResetStoreDoneForClearAll(
     const base::Closure& callback,
     bool success) {
   DCHECK(success);
   if (!success) {
+    offline_event_logger_.RecordStoreClearError();
     UMA_HISTOGRAM_ENUMERATION("OfflinePages.ClearAllStatus2",
                               STORE_RESET_FAILED, CLEAR_ALL_STATUS_COUNT);
   }
 
   offline_pages_.clear();
   store_->Load(base::Bind(&OfflinePageModelImpl::OnReloadStoreDoneForClearAll,
                           weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void OfflinePageModelImpl::OnReloadStoreDoneForClearAll(
     const base::Closure& callback,
     OfflinePageMetadataStore::LoadStatus load_status,
     const std::vector<OfflinePageItem>& offline_pages) {
   DCHECK_EQ(OfflinePageMetadataStore::LOAD_SUCCEEDED, load_status);
   UMA_HISTOGRAM_ENUMERATION(
       "OfflinePages.ClearAllStatus2",
       load_status == OfflinePageMetadataStore::LOAD_SUCCEEDED
           ? CLEAR_ALL_SUCCEEDED
           : STORE_RELOAD_FAILED,
       CLEAR_ALL_STATUS_COUNT);
 
+  if (load_status == OfflinePageMetadataStore::LOAD_SUCCEEDED)
+    offline_event_logger_.RecordStoreCleared();
+  else
+    offline_event_logger_.RecordStoreReloadError();
+
   CacheLoadedData(offline_pages);
   callback.Run();
 }
 
 void OfflinePageModelImpl::CacheLoadedData(
     const std::vector<OfflinePageItem>& offline_pages) {
   offline_pages_.clear();
   for (const auto& offline_page : offline_pages)
     offline_pages_[offline_page.offline_id] = offline_page;
 }
@@ skipping 17 matching lines @@
 void OfflinePageModelImpl::RunWhenLoaded(const base::Closure& task) {
   if (!is_loaded_) {
     delayed_tasks_.push_back(task);
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);
 }
 
 }  // namespace offline_pages