[Offline Pages] Link the internals page with the offline model and request

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 <string>
+#include <stdint.h>
+#include <stdlib.h>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.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/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"
 
 namespace {
 
 // Class acting as a controller of the chrome://offline-internals WebUI.
 class OfflineInternalsUIMessageHandler : public content::WebUIMessageHandler {
  public:
   OfflineInternalsUIMessageHandler();
   ~OfflineInternalsUIMessageHandler() override;
 
   // WebUIMessageHandler implementation.
   void RegisterMessages() override;
 
  private:
   // Deletes all the pages in the store.
   void DeleteAllPages(const base::ListValue* args);
 
   // Delete selected list of page ids from the store.
   void DeleteSelectedPages(const base::ListValue* args);
 
-  // Load all information.
-  void GetOfflineInternalsInfo(const base::ListValue* args);
+  // Load Request Queue info.
+  void GetRequestQueue(const base::ListValue* args);
+
+  // Load Stored pages info.
+  void GetStoredPages(const base::ListValue* args);
+
+  // Callback for async GetAllPages calls.
+  void HandleStoredPages(
+      std::string callback_id,
+      const offline_pages::MultipleOfflinePageItemResult& pages);
+
+  // Callback for async GetRequests calls.
+  void HandleRequestQueue(
+      std::string callback_id,
+      offline_pages::RequestQueue::GetRequestsResult result,
+      const std::vector<offline_pages::SavePageRequest>& requests);
+
+  // Callback for DeletePage/ClearAll calls.
+  void HandleDeletedPages(std::string callback_id,
+                          const offline_pages::DeletePageResult result);
+
+  std::string GetStringFromDeletePageResult(

[dewittj, 2016/06/03 23:12:06]

Please define out of line.

This might be better defined in offline_page_types.h so that people adding new
statuses will be inclined to add a new one.  Same with SavePageStatus

[chili, 2016/06/09 22:29:16]

I was hesitating between putting this here vs offline_page_types.h.  Nowhere
else seems to need these statuses in string form so it doesn't seem to quite fit
in offline_page_types.  I figured if they needed to see the status in the
internals page, they'll see 'Unknown" and try to update.

[dewittj, 2016/06/09 23:41:25]

Not everyone is going to necessarily use this page all the time... Could you at
least add a comment at DeletePageResult's definition (and SavePageResult) to
update the list here when changing the enums?

+      offline_pages::DeletePageResult value) {
+    const std::string kDeletePageResultToString[] = {
+        "Success", "Canceled", "Store failure", "Device failure", "Not found"};
+    int int_value = static_cast<int>(value);
+    if (int_value >= 5)
+      return "Unknown";
+    else
+      return kDeletePageResultToString[int_value];
+  }
+
+  std::string GetStringFromSavePageStatus(
+      offline_pages::SavePageRequest::Status status) {
+    const std::string kRequestStatusToString[] = {
+        "Not ready", "Pending", "Started", "Failed", "Expired"};
+    int int_value = static_cast<int>(status);
+    if (int_value >= 5)
+      return "Unknown";
+    else
+      return kRequestStatusToString[int_value];
+  }
+
+  // Offline page model to call methods on.
+  offline_pages::OfflinePageModel* offline_page_model_;
+  // Request coordinator for background offline actions.
+  offline_pages::RequestCoordinator* request_coordinator_;
 
   // Factory for creating references in callbacks.
   base::WeakPtrFactory<OfflineInternalsUIMessageHandler> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(OfflineInternalsUIMessageHandler);
 };
 
 OfflineInternalsUIMessageHandler::OfflineInternalsUIMessageHandler()
     : weak_ptr_factory_(this) {}
 
 OfflineInternalsUIMessageHandler::~OfflineInternalsUIMessageHandler() {}
 
 void OfflineInternalsUIMessageHandler::DeleteAllPages(
     const base::ListValue* args) {
   std::string callback_id;
   args->GetString(0, &callback_id);
-  web_ui()->CallJavascriptFunction("cr.webUIResponse",
-      base::StringValue(callback_id),
-      base::FundamentalValue(true),
-      base::StringValue("success"));
+
+  offline_page_model_->ClearAll(
+      base::Bind(&OfflineInternalsUIMessageHandler::HandleDeletedPages,
+                 weak_ptr_factory_.GetWeakPtr(), callback_id,
+                 offline_pages::DeletePageResult::SUCCESS));

[dewittj, 2016/06/03 23:12:06]

Please add a comment that this is here because ClearAll does not call back with
a status code.

[chili, 2016/06/09 22:29:16]

Done.

 }
 
 void OfflineInternalsUIMessageHandler::DeleteSelectedPages(
     const base::ListValue* args) {
   std::string callback_id;
   args->GetString(0, &callback_id);
-  web_ui()->CallJavascriptFunction("cr.webUIResponse",
-      base::StringValue(callback_id),
-      base::FundamentalValue(true),
-      base::StringValue("success"));
+
+  std::vector<int64_t> offline_ids;
+  const base::ListValue* offline_ids_from_arg;
+  args->GetList(1, &offline_ids_from_arg);
+
+  for (size_t i = 0; i < offline_ids_from_arg->GetSize(); i++) {
+    std::string value;
+    offline_ids_from_arg->GetString(i, &value);
+    offline_ids.push_back(atoll(value.c_str()));

[dewittj, 2016/06/03 23:12:06]

not sure if there is some function in Chromium to use besides atoll.   strtoll
is probably preferred (since you can set base there)...

There is also ParseInt64, but that's in net::, so not really likely to be used
for general purpose parsing.

[chili, 2016/06/09 22:29:16]

you can set base in strtoll, but I didn't think the extra parameters were
necessary...

+  }
+
+  offline_page_model_->DeletePagesByOfflineId(
+      offline_ids,
+      base::Bind(&OfflineInternalsUIMessageHandler::HandleDeletedPages,
+                 weak_ptr_factory_.GetWeakPtr(), callback_id));
 }
 
-void OfflineInternalsUIMessageHandler::GetOfflineInternalsInfo(
+void OfflineInternalsUIMessageHandler::HandleDeletedPages(
+    std::string callback_id,
+    offline_pages::DeletePageResult result) {
+  web_ui()->CallJavascriptFunction(
+      "cr.webUIResponse", base::StringValue(callback_id),
+      base::FundamentalValue(true),
+      base::StringValue(GetStringFromDeletePageResult(result)));
+}
+
+void OfflineInternalsUIMessageHandler::HandleStoredPages(
+    std::string callback_id,
+    const offline_pages::MultipleOfflinePageItemResult& pages) {
+  base::ListValue results;
+
+  for (const auto& page : pages) {
+    base::DictionaryValue* js_page_object = new base::DictionaryValue();
+    results.Append(js_page_object);
+    js_page_object->SetString("onlineUrl", page.url.spec());

[dewittj, 2016/06/03 23:12:06]

I wish we didn't have so many hard-coded strings around but I don't know how to
change that.

[chili, 2016/06/09 22:29:16]

I do too, but I chose to hard-code them here rather than setting constants
because - they're only used once in this cc file, and the javascript can't
reference these constants anyway.

When I talked with dpapad@, he mentioned he's going for a mojom (mojo-like)
approach that would be able to autogenerate these things given a common schema. 
We might be able to eliminate this kind of hard coding altogether, though the
timing may be months in the future.

+    js_page_object->SetString("namespace", page.client_id.name_space);
+    js_page_object->SetDouble("size", page.file_size);
+    js_page_object->SetString("id", std::to_string(page.offline_id));
+    js_page_object->SetString("filePath", page.file_path.value());
+    js_page_object->SetDouble("creationTime", page.creation_time.ToJsTime());
+    js_page_object->SetDouble("lastAccessedTime",
+                              page.last_access_time.ToJsTime());
+    js_page_object->SetInteger("accessCount", page.access_count);
+  }
+  web_ui()->CallJavascriptFunction("cr.webUIResponse",
+                                   base::StringValue(callback_id),
+                                   base::FundamentalValue(true), results);
+}
+
+void OfflineInternalsUIMessageHandler::HandleRequestQueue(
+    std::string callback_id,
+    offline_pages::RequestQueue::GetRequestsResult result,
+    const std::vector<offline_pages::SavePageRequest>& requests) {
+  base::ListValue js_requests;
+  if (result == offline_pages::RequestQueue::GetRequestsResult::kSuccess) {
+    for (const auto& request : requests) {
+      base::DictionaryValue* js_request_object = new base::DictionaryValue();
+      js_requests.Append(js_request_object);
+      js_request_object->SetString("onlineUrl", request.url().spec());
+      js_request_object->SetDouble("creationTime",
+                                   request.creation_time().ToJsTime());
+      js_request_object->SetString(
+          "status",
+          GetStringFromSavePageStatus(request.GetStatus(base::Time::Now())));
+      js_request_object->SetString("namespace", request.client_id().name_space);
+      js_request_object->SetDouble("lastAttempt",
+                                   request.last_attempt_time().ToJsTime());
+      js_request_object->SetString("id", std::to_string(request.request_id()));
+    }
+  }
+  web_ui()->CallJavascriptFunction("cr.webUIResponse",
+                                   base::StringValue(callback_id),
+                                   base::FundamentalValue(true), js_requests);
+}
+
+void OfflineInternalsUIMessageHandler::GetRequestQueue(
     const base::ListValue* args) {
   std::string callback_id;
   args->GetString(0, &callback_id);
-  base::DictionaryValue results;
-  results.Set("AllPages", new base::ListValue());
-  results.Set("Queue", new base::ListValue());
+  base::ListValue results;
 
-  web_ui()->CallJavascriptFunction("cr.webUIResponse",
-      base::StringValue(callback_id),
-      base::FundamentalValue(true),
-      results);
+  if (request_coordinator_ != nullptr)
+    request_coordinator_->queue()->GetRequests(
+        base::Bind(&OfflineInternalsUIMessageHandler::HandleRequestQueue,
+                   weak_ptr_factory_.GetWeakPtr(), callback_id));
+}
+
+void OfflineInternalsUIMessageHandler::GetStoredPages(
+    const base::ListValue* args) {
+  std::string callback_id;
+  args->GetString(0, &callback_id);
+  base::ListValue results;
+
+  if (offline_page_model_ != nullptr)
+    offline_page_model_->GetAllPages(
+        base::Bind(&OfflineInternalsUIMessageHandler::HandleStoredPages,
+                   weak_ptr_factory_.GetWeakPtr(), callback_id));
 }
 
 void OfflineInternalsUIMessageHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "deleteAllPages",
       base::Bind(&OfflineInternalsUIMessageHandler::DeleteAllPages,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback(
       "deleteSelectedPages",
       base::Bind(&OfflineInternalsUIMessageHandler::DeleteSelectedPages,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback(
-      "getOfflineInternalsInfo",
-      base::Bind(&OfflineInternalsUIMessageHandler::GetOfflineInternalsInfo,
+      "getRequestQueueInfo",
+      base::Bind(&OfflineInternalsUIMessageHandler::GetRequestQueue,
                  weak_ptr_factory_.GetWeakPtr()));
+  web_ui()->RegisterMessageCallback(
+      "getStoredPagesInfo",
+      base::Bind(&OfflineInternalsUIMessageHandler::GetStoredPages,
+                 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
 
 OfflineInternalsUI::OfflineInternalsUI(content::WebUI* web_ui)
     : content::WebUIController(web_ui) {
   // chrome://offline-internals source.
   content::WebUIDataSource* html_source =
       content::WebUIDataSource::Create(chrome::kChromeUIOfflineInternalsHost);
 
   // Required resources.
   html_source->SetJsonPath("strings.js");
   html_source->AddResourcePath("offline_internals.css",
                                IDR_OFFLINE_INTERNALS_CSS);
   html_source->AddResourcePath("offline_internals.js",
                                IDR_OFFLINE_INTERNALS_JS);
   html_source->SetDefaultResource(IDR_OFFLINE_INTERNALS_HTML);
 
   content::WebUIDataSource::Add(Profile::FromWebUI(web_ui), html_source);
 
   web_ui->AddMessageHandler(new OfflineInternalsUIMessageHandler());
 }
 
 OfflineInternalsUI::~OfflineInternalsUI() {}