[Offline pages] Extract internals page interaction with browser to a proxy

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 27 matching lines @@
   void RegisterMessages() override;
 
  private:
   // Deletes all the pages in the store.
   void HandleDeleteAllPages(const base::ListValue* args);
 
   // Delete selected list of page ids from the store.
   void HandleDeleteSelectedPages(const base::ListValue* args);
 
   // Load Request Queue info.
-  void HandleGetRequestQueueInfo(const base::ListValue* args);
+  void HandleGetRequestQueue(const base::ListValue* args);
 
   // Load Stored pages info.
-  void HandleGetStoredPagesInfo(const base::ListValue* args);
+  void HandleGetStoredPages(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,
@@ skipping 149 matching lines @@
           GetStringFromSavePageStatus(request.GetStatus(base::Time::Now())));
       save_page_request->SetString("namespace", request.client_id().name_space);
       save_page_request->SetDouble("lastAttempt",
                                    request.last_attempt_time().ToJsTime());
       save_page_request->SetString("id", std::to_string(request.request_id()));
     }
   }
   ResolveJavascriptCallback(base::StringValue(callback_id), save_page_requests);
 }
 
-void OfflineInternalsUIMessageHandler::HandleGetRequestQueueInfo(
+void OfflineInternalsUIMessageHandler::HandleGetRequestQueue(
     const base::ListValue* args) {
   AllowJavascript();
   std::string callback_id;
   CHECK(args->GetString(0, &callback_id));
 
   if (request_coordinator_) {
     request_coordinator_->queue()->GetRequests(base::Bind(
         &OfflineInternalsUIMessageHandler::HandleRequestQueueCallback,
         weak_ptr_factory_.GetWeakPtr(), callback_id));
   } else {
     base::ListValue results;
     ResolveJavascriptCallback(base::StringValue(callback_id), results);
   }
 }
 
-void OfflineInternalsUIMessageHandler::HandleGetStoredPagesInfo(
+void OfflineInternalsUIMessageHandler::HandleGetStoredPages(
     const base::ListValue* args) {
   AllowJavascript();
   std::string callback_id;
   CHECK(args->GetString(0, &callback_id));
 
   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::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(
-      "getRequestQueueInfo",
-      base::Bind(&OfflineInternalsUIMessageHandler::HandleGetRequestQueueInfo,
+      "getRequestQueue",
+      base::Bind(&OfflineInternalsUIMessageHandler::HandleGetRequestQueue,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback(
-      "getStoredPagesInfo",
-      base::Bind(&OfflineInternalsUIMessageHandler::HandleGetStoredPagesInfo,
+      "getStoredPages",
+      base::Bind(&OfflineInternalsUIMessageHandler::HandleGetStoredPages,
                  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->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() {}