[Offline Pages] Add network status, save request textbox, and offline url link to offline internals…

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>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
 #include "chrome/browser/android/offline_pages/request_coordinator_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/url_constants.h"
 #include "components/offline_pages/background/request_coordinator.h"
 #include "components/offline_pages/background/save_page_request.h"
+#include "components/offline_pages/client_namespace_constants.h"
 #include "components/offline_pages/offline_page_model.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_controller.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "grit/browser_resources.h"
+#include "net/base/network_change_notifier.h"
 
 namespace {
 
 // Class acting as a controller of the chrome://offline-internals WebUI.
+// TODO(chili): Should split this file and move to webui/offline_internals/
 class OfflineInternalsUIMessageHandler : public content::WebUIMessageHandler {
  public:
   OfflineInternalsUIMessageHandler();
   ~OfflineInternalsUIMessageHandler() override;
 
   // WebUIMessageHandler implementation.
   void RegisterMessages() override;
 
  private:
   // Deletes all the pages in the store.
@@ skipping 13 matching lines @@
 
   // 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);
 
+  // Adds a url to the background loader queue.
+  void HandleAddToRequestQueue(const base::ListValue* args);
+
+  // Load whether device is currently offline.
+  void HandleGetNetworkStatus(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 115 matching lines @@
     const offline_pages::MultipleOfflinePageItemResult& pages) {
   base::ListValue results;
 
   for (const auto& page : pages) {
     base::DictionaryValue* offline_page = new base::DictionaryValue();
     results.Append(offline_page);
     offline_page->SetString("onlineUrl", page.url.spec());
     offline_page->SetString("namespace", page.client_id.name_space);
     offline_page->SetDouble("size", page.file_size);
     offline_page->SetString("id", std::to_string(page.offline_id));
-    offline_page->SetString("filePath", page.file_path.value());
+    offline_page->SetString("filePath", page.GetOfflineURL().spec());
     offline_page->SetDouble("creationTime", page.creation_time.ToJsTime());
     offline_page->SetDouble("lastAccessTime",
                               page.last_access_time.ToJsTime());
     offline_page->SetInteger("accessCount", page.access_count);
     offline_page->SetString("isExpired", page.IsExpired() ? "Yes" : "No");
   }
   ResolveJavascriptCallback(base::StringValue(callback_id), results);
 }
 
 void OfflineInternalsUIMessageHandler::HandleRequestQueueCallback(
@@ skipping 52 matching lines @@
   }
 }
 
 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::HandleGetNetworkStatus(
+    const base::ListValue* args) {
+  const base::Value* callback_id;
+  CHECK(args->Get(0, &callback_id));
+
+  ResolveJavascriptCallback(
+      *callback_id,
+      base::StringValue(
+          net::NetworkChangeNotifier::IsOffline() ? "Offline" : "Online"));
+}
+
 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();
@@ skipping 18 matching lines @@
   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::HandleAddToRequestQueue(
+    const base::ListValue* args) {
+  const base::Value* callback_id;
+  CHECK(args->Get(0, &callback_id));
+
+  std::string url;
+  CHECK(args->GetString(1, &url));
+
+  std::ostringstream id_stream;
+  id_stream << std::rand();
+
+  ResolveJavascriptCallback(
+      *callback_id,
+      base::FundamentalValue(
+          request_coordinator_->SavePageLater(
+              GURL(url),
+              offline_pages::ClientId(offline_pages::kAsyncNamespace,
+                                      id_stream.str()),
+              true)));
+}
+
 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(
@@ skipping 13 matching lines @@
       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()));
+  web_ui()->RegisterMessageCallback(
+      "addToRequestQueue",
+      base::Bind(&OfflineInternalsUIMessageHandler::HandleAddToRequestQueue,
+                 weak_ptr_factory_.GetWeakPtr()));
+  web_ui()->RegisterMessageCallback(
+      "getNetworkStatus",
+      base::Bind(&OfflineInternalsUIMessageHandler::HandleGetNetworkStatus,
+                 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() {}