Adds a delete button to chrome:offline-internals

chrome/browser/ui/webui/offline/offline_internals_ui_message_handler.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/offline_internals_ui_message_handler.h"
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <vector>
 
@@ skipping 29 matching lines @@
       return "Device failure";
     case offline_pages::DeletePageResult::NOT_FOUND:
       return "Not found";
     case offline_pages::DeletePageResult::RESULT_COUNT:
       break;
   }
   NOTREACHED();
   return "Unknown";
 }
 
+std::string OfflineInternalsUIMessageHandler::GetStringFromDeleteRequestResults(
+    const offline_pages::RequestQueue::UpdateMultipleRequestResults& results) {
+  // If any requests failed, return "failure", else "success".
+  bool failed = false;
+  std::string failed_ids;
+  for (const auto& result : results) {
+    if (result.second ==
+        offline_pages::RequestQueue::UpdateRequestResult::STORE_FAILURE) {
+      failed = true;
+      failed_ids += std::to_string(result.first);
+      failed_ids += ", ";
+    }
+  }
+  if (failed)
+    return "Store failure, could not delete urls: " + failed_ids;

[chili, 2016/09/12 23:09:48]

nit: "Store failure, could not delete ids: " ?

I'm happy with IDs.  Something to think about though - we don't actually show
request_ids anywhere in the table UI.  Would a list of failed IDs be useful
somehow?  If not, perhaps just having a message like "Deletion failed for one or
more requests" would suffice

[Pete Williamson, 2016/09/13 00:47:56]

Good point, the request ID is not that helpful.  Maybe a less informational
error string is better.

+  return "Success";
+}
+
 std::string OfflineInternalsUIMessageHandler::GetStringFromSavePageStatus() {
   return "Available";
 }
 
 void OfflineInternalsUIMessageHandler::HandleDeleteAllPages(
     const base::ListValue* args) {
   std::string callback_id;
   CHECK(args->GetString(0, &callback_id));
 
   // Pass back success because ClearAll doesn't return a status.
@@ skipping 19 matching lines @@
     base::StringToInt64(value, &int_value);
     offline_ids.push_back(int_value);
   }
 
   offline_page_model_->DeletePagesByOfflineId(
       offline_ids,
       base::Bind(&OfflineInternalsUIMessageHandler::HandleDeletedPagesCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback_id));
 }
 
+void OfflineInternalsUIMessageHandler::HandleDeleteAllRequests(
+    const base::ListValue* args) {
+  std::string callback_id;
+  CHECK(args->GetString(0, &callback_id));
+  // First do a get, then in the callback, build a list of IDs, and
+  // call RemoveRequests with that list.
+  if (request_coordinator_) {
+    request_coordinator_->GetAllRequests(
+        base::Bind(&OfflineInternalsUIMessageHandler::
+                       HandleGetAllRequestsForDeleteCallback,
+                   weak_ptr_factory_.GetWeakPtr(), callback_id));
+  }
+}
+
+void OfflineInternalsUIMessageHandler::HandleDeleteSelectedRequests(
+    const base::ListValue* args) {
+  std::string callback_id;
+  CHECK(args->GetString(0, &callback_id));
+
+  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);
+    int64_t int_value;
+    base::StringToInt64(value, &int_value);
+    offline_ids.push_back(int_value);
+  }
+
+  // Call RequestCoordinator to delete them
+  if (request_coordinator_) {
+    request_coordinator_->RemoveRequests(
+        offline_ids,
+        base::Bind(
+            &OfflineInternalsUIMessageHandler::HandleDeletedRequestsCallback,
+            weak_ptr_factory_.GetWeakPtr(), callback_id));
+  }
+}
+
+void OfflineInternalsUIMessageHandler::HandleGetAllRequestsForDeleteCallback(
+    std::string callback_id,
+    std::vector<std::unique_ptr<offline_pages::SavePageRequest>> requests) {
+  std::vector<int64_t> offline_ids;
+  // Build a list of offline_ids from the requests.
+  for (const auto& request : requests) {
+    offline_ids.push_back(request->request_id());
+  }
+
+  // Call RequestCoordinator to delete them
+  if (request_coordinator_) {
+    request_coordinator_->RemoveRequests(
+        offline_ids,
+        base::Bind(
+            &OfflineInternalsUIMessageHandler::HandleDeletedRequestsCallback,
+            weak_ptr_factory_.GetWeakPtr(), callback_id));
+  }
+}
+
 void OfflineInternalsUIMessageHandler::HandleDeletedPagesCallback(
     std::string callback_id,
     offline_pages::DeletePageResult result) {
   ResolveJavascriptCallback(
       base::StringValue(callback_id),
       base::StringValue(GetStringFromDeletePageResult(result)));
 }
 
+void OfflineInternalsUIMessageHandler::HandleDeletedRequestsCallback(
+    std::string callback_id,
+    const offline_pages::RequestQueue::UpdateMultipleRequestResults& results) {
+  ResolveJavascriptCallback(
+      base::StringValue(callback_id),
+      base::StringValue(GetStringFromDeleteRequestResults(results)));
+}
+
 void OfflineInternalsUIMessageHandler::HandleStoredPagesCallback(
     std::string callback_id,
     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);
@@ skipping 155 matching lines @@
 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(
+      "deleteAllRequests",
+      base::Bind(&OfflineInternalsUIMessageHandler::HandleDeleteAllRequests,
+                 weak_ptr_factory_.GetWeakPtr()));
+  web_ui()->RegisterMessageCallback(
+      "deleteSelectedRequests",
+      base::Bind(
+          &OfflineInternalsUIMessageHandler::HandleDeleteSelectedRequests,
+          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,
@@ skipping 21 matching lines @@
 
   // 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 offline_internals