[Offline Pages] Connect the offline page logs to the internals page.

chrome/browser/ui/webui/offline_internals_ui.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 "chrome/browser/ui/webui/offline_internals_ui.h"
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <vector>
 
@@ skipping 32 matching lines @@
 
   // Delete selected list of page ids from the store.
   void HandleDeleteSelectedPages(const base::ListValue* args);
 
   // Load Request Queue info.
   void HandleGetRequestQueue(const base::ListValue* args);
 
   // Load Stored pages info.
   void HandleGetStoredPages(const base::ListValue* args);
 
+  // Set whether to record offline page model events.
+  void HandleSetRecordPageModel(const base::ListValue* args);
+
+  // Set whether to record request queue events.
+  void HandleSetRecordRequestQueue(const base::ListValue* args);
+
+  // Load both Page Model and Request Queue event logs.
+  void HandleGetEventLogs(const base::ListValue* args);
+
+  // Load whether logs are being recorded.
+  void HandleGetLoggingState(const base::ListValue* args);
+
   // Callback for async GetAllPages calls.
   void HandleStoredPagesCallback(
       std::string callback_id,
       const offline_pages::MultipleOfflinePageItemResult& pages);
 
   // Callback for async GetRequests calls.
   void HandleRequestQueueCallback(
       std::string callback_id,
       offline_pages::RequestQueue::GetRequestsResult result,
       const std::vector<offline_pages::SavePageRequest>& requests);
@@ skipping 180 matching lines @@
   if (offline_page_model_) {
     offline_page_model_->GetAllPages(
         base::Bind(&OfflineInternalsUIMessageHandler::HandleStoredPagesCallback,
                    weak_ptr_factory_.GetWeakPtr(), callback_id));
   } else {
     base::ListValue results;
     ResolveJavascriptCallback(base::StringValue(callback_id), results);
   }
 }
 
+void OfflineInternalsUIMessageHandler::HandleSetRecordPageModel(
+    const base::ListValue* args) {
+  bool should_record;
+  CHECK(args->GetBoolean(0, &should_record));
+  offline_page_model_->GetLogger()->SetIsLogging(should_record);
+}
+
+void OfflineInternalsUIMessageHandler::HandleSetRecordRequestQueue(
+    const base::ListValue* args) {
+  bool should_record;
+  CHECK(args->GetBoolean(0, &should_record));
+  request_coordinator_->GetLogger()->SetIsLogging(should_record);
+}
+
+void OfflineInternalsUIMessageHandler::HandleGetLoggingState(
+    const base::ListValue* args) {
+  AllowJavascript();
+  const base::Value* callback_id;
+  CHECK(args->Get(0, &callback_id));
+
+  base::DictionaryValue result;
+  result.SetBoolean("modelIsLogging",
+                    offline_page_model_->GetLogger()->GetIsLogging());
+  result.SetBoolean("queueIsLogging",
+                    request_coordinator_->GetLogger()->GetIsLogging());
+  ResolveJavascriptCallback(*callback_id, result);
+}
+
+void OfflineInternalsUIMessageHandler::HandleGetEventLogs(
+    const base::ListValue* args) {
+  AllowJavascript();
+  const base::Value* callback_id;
+  CHECK(args->Get(0, &callback_id));
+
+  std::vector<std::string> logs;
+  offline_page_model_->GetLogger()->GetLogs(&logs);
+  request_coordinator_->GetLogger()->GetLogs(&logs);
+  std::sort(logs.begin(), logs.end());
+
+  base::ListValue result;
+  result.AppendStrings(logs);
+
+  ResolveJavascriptCallback(*callback_id, result);
+}
+
 void OfflineInternalsUIMessageHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "deleteAllPages",
       base::Bind(&OfflineInternalsUIMessageHandler::HandleDeleteAllPages,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback(
       "deleteSelectedPages",
       base::Bind(&OfflineInternalsUIMessageHandler::HandleDeleteSelectedPages,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback(
       "getRequestQueue",
       base::Bind(&OfflineInternalsUIMessageHandler::HandleGetRequestQueue,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback(
       "getStoredPages",
       base::Bind(&OfflineInternalsUIMessageHandler::HandleGetStoredPages,
                  weak_ptr_factory_.GetWeakPtr()));
+  web_ui()->RegisterMessageCallback(
+      "getEventLogs",
+      base::Bind(&OfflineInternalsUIMessageHandler::HandleGetEventLogs,
+                 weak_ptr_factory_.GetWeakPtr()));
+  web_ui()->RegisterMessageCallback(
+      "setRecordRequestQueue",
+      base::Bind(&OfflineInternalsUIMessageHandler::HandleSetRecordRequestQueue,
+                 weak_ptr_factory_.GetWeakPtr()));
+  web_ui()->RegisterMessageCallback(
+      "setRecordPageModel",
+      base::Bind(&OfflineInternalsUIMessageHandler::HandleSetRecordPageModel,
+                 weak_ptr_factory_.GetWeakPtr()));
+  web_ui()->RegisterMessageCallback(
+      "getLoggingState",
+      base::Bind(&OfflineInternalsUIMessageHandler::HandleGetLoggingState,
+                 weak_ptr_factory_.GetWeakPtr()));
 
   // Get the offline page model associated with this web ui.
   Profile* profile = Profile::FromWebUI(web_ui());
   offline_page_model_ =
       offline_pages::OfflinePageModelFactory::GetForBrowserContext(profile);
   request_coordinator_ =
       offline_pages::RequestCoordinatorFactory::GetForBrowserContext(profile);
 }
 
 }  // namespace
@@ skipping 13 matching lines @@
   html_source->AddResourcePath("offline_internals_browser_proxy.js",
                                IDR_OFFLINE_INTERNALS_BROWSER_PROXY_JS);
   html_source->SetDefaultResource(IDR_OFFLINE_INTERNALS_HTML);
 
   content::WebUIDataSource::Add(Profile::FromWebUI(web_ui), html_source);
 
   web_ui->AddMessageHandler(new OfflineInternalsUIMessageHandler());
 }
 
 OfflineInternalsUI::~OfflineInternalsUI() {}