Define all the Webview proto messages

Adds the proto definitions to all the remaining Webview calls.
Also implement all the straightforward calls.

TODOs:
 * Javascript message channels,
 * Navigation delegate,
 * Clear cache on the renderer side.

Bug: b/132811925
Test: Compiled
Change-Id: If8cb03e1e26ece586ed841dcdd028a6c5ccf0316
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1830171Reviewed-by: Alex Sakhartchouk <alexst@chromium.org>
Commit-Queue: Daniel Nicoara <dnicoara@chromium.org>
Cr-Commit-Position: refs/heads/master@{#701114}

chromecast/browser/webview/proto/webview.proto

@@ -22,8 +22,6 @@ message WebviewCreateRequest {
   // This identifies the surface that this webview will display into.
   // It should be unique and the same as whatever was set into
   // |aura_surface_set_client_surface_id| on the wayland surface.
-  // It is an error to attempt to create a webview if the surface
-  // does not yet exist.
   int32 webview_id = 1;
   // This is the cast window ID that will be assigned to the web contents
   // window.
@@ -101,6 +99,75 @@ message StopPageRequest {
   int32 error_code = 1;
 }
 
+message EvaluateJavascriptRequest {
+  string javascript_blob = 1;
+}
+
+message EvaluateJavascriptResponse {
+  string json = 1;
+}
+
+message AddJavascriptChannelsRequest {
+  repeated string channels = 1;
+}
+
+message RemoveJavascriptChannelsRequest {
+  repeated string channels = 1;
+}
+
+message GetCurrentUrlRequest {}
+
+message GetCurrentUrlResponse {
+  string url = 1;
+}
+
+message CanGoBackRequest {}
+
+message CanGoBackResponse {
+  bool can_go_back = 1;
+}
+
+message CanGoForwardRequest {}
+
+message CanGoForwardResponse {
+  bool can_go_forward = 1;
+}
+
+message GoBackRequest {}
+
+message GoForwardRequest {}
+
+message ReloadRequest {}
+
+message ClearCacheRequest {}
+
+message UserAgent {
+  oneof type {
+    bool is_null = 1;
+    string value = 2;
+  }
+}
+
+message UpdateSettingsRequest {
+  bool javascript_enabled = 1;
+  bool has_navigation_delegate = 2;
+  bool debugging_enabled = 3;
+  // A null value means the default user agent should be used.
+  // An absent value represents no change to this setting from the last time it
+  // was set.
+  UserAgent user_agent = 4;
+}
+
+message GetTitleRequest {}
+
+message GetTitleResponse {
+  string title = 1;
+}
+
+message SetAutoMediaPlaybackPolicyRequest {
+  bool require_user_gesture = 1;
+}
+
 message WebviewRequest {
   oneof type {
     // This must be the first message.
@@ -111,6 +178,32 @@ message WebviewRequest {
     NavigateRequest navigate = 3;
     // Expect page events to follow.
     StopPageRequest stop_page = 4;
+    // Expect async response.
+    EvaluateJavascriptRequest evaluate_javascript = 5;
+    // No response.
+    AddJavascriptChannelsRequest add_javascript_channels = 6;
+    // No response.
+    RemoveJavascriptChannelsRequest remove_javascript_channels = 7;
+    // Expect async response.
+    GetCurrentUrlRequest get_current_url = 8;
+    // Expect async response.
+    CanGoBackRequest can_go_back = 9;
+    // Expect async response.
+    CanGoForwardRequest can_go_forward = 10;
+    // No response.
+    GoBackRequest go_back = 11;
+    // No response.
+    GoForwardRequest go_forward = 12;
+    // No response.
+    ReloadRequest reload = 13;
+    // No response.
+    ClearCacheRequest clear_cache = 14;
+    // No response.
+    UpdateSettingsRequest update_settings = 15;
+    // Expect async response.
+    GetTitleRequest get_title = 16;
+    // No response.
+    SetAutoMediaPlaybackPolicyRequest set_auto_media_playback_policy = 17;
   }
 }
 
@@ -118,9 +211,15 @@ message WebviewResponse {
   oneof type {
     WebviewCreateResponse create_response = 1;
     AsyncPageEvent page_event = 2;
+    EvaluateJavascriptResponse evaluate_javascript = 3;
+    GetCurrentUrlResponse get_current_url = 4;
+    CanGoBackResponse can_go_back = 5;
+    CanGoForwardResponse can_go_forward = 6;
+    GetTitleResponse get_title = 7;
   }
 }
 
 service WebviewService {
+  // Creates a webview. See the comment at the top of the file.
   rpc CreateWebview(stream WebviewRequest) returns (stream WebviewResponse);
 }

chromecast/browser/webview/webview_controller.cc

@@ -4,11 +4,17 @@
 
 #include "chromecast/browser/webview/webview_controller.h"
 
+#include "base/json/json_writer.h"
+#include "base/strings/utf_string_conversions.h"
 #include "chromecast/base/version.h"
 #include "chromecast/browser/cast_web_contents_impl.h"
 #include "chromecast/browser/webview/proto/webview.pb.h"
 #include "chromecast/browser/webview/webview_layout_manager.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browsing_data_remover.h"
+#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/web_preferences.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/events/event.h"
@@ -62,6 +68,81 @@ void WebviewController::ProcessRequest(const webview::WebviewRequest& request) {
       }
       break;
 
+    case webview::WebviewRequest::kEvaluateJavascript:
+      if (request.has_evaluate_javascript()) {
+        HandleEvaluateJavascript(request.evaluate_javascript());
+      } else {
+        client_->OnError("evaluate_javascript() not supplied");
+      }
+      break;
+
+    case webview::WebviewRequest::kAddJavascriptChannels:
+      if (request.has_add_javascript_channels()) {
+        HandleAddJavascriptChannels(request.add_javascript_channels());
+      } else {
+        client_->OnError("add_javascript_channels() not supplied");
+      }
+      break;
+
+    case webview::WebviewRequest::kRemoveJavascriptChannels:
+      if (request.has_remove_javascript_channels()) {
+        HandleRemoveJavascriptChannels(request.remove_javascript_channels());
+      } else {
+        client_->OnError("remove_javascript_channels() not supplied");
+      }
+      break;
+
+    case webview::WebviewRequest::kGetCurrentUrl:
+      HandleGetCurrentUrl();
+      break;
+
+    case webview::WebviewRequest::kCanGoBack:
+      HandleCanGoBack();
+      break;
+
+    case webview::WebviewRequest::kCanGoForward:
+      HandleCanGoForward();
+      break;
+
+    case webview::WebviewRequest::kGoBack:
+      contents_->GetController().GoBack();
+      break;
+
+    case webview::WebviewRequest::kGoForward:
+      contents_->GetController().GoForward();
+      break;
+
+    case webview::WebviewRequest::kReload:
+      // TODO(dnicoara): Are the default parameters correct?
+      contents_->GetController().Reload(content::ReloadType::NORMAL,
+                                        /*check_for_repost=*/true);
+      break;
+
+    case webview::WebviewRequest::kClearCache:
+      HandleClearCache();
+      break;
+
+    case webview::WebviewRequest::kUpdateSettings:
+      if (request.has_update_settings()) {
+        HandleUpdateSettings(request.update_settings());
+      } else {
+        client_->OnError("update_settings() not supplied");
+      }
+      break;
+
+    case webview::WebviewRequest::kGetTitle:
+      HandleGetTitle();
+      break;
+
+    case webview::WebviewRequest::kSetAutoMediaPlaybackPolicy:
+      if (request.has_set_auto_media_playback_policy()) {
+        HandleSetAutoMediaPlaybackPolicy(
+            request.set_auto_media_playback_policy());
+      } else {
+        client_->OnError("set_auto_media_playback_policy() not supplied");
+      }
+      break;
+
     default:
       client_->OnError("Unknown request code");
       break;
@@ -134,6 +215,115 @@ void WebviewController::ProcessInputEvent(const webview::InputEvent& ev) {
   }
 }
 
+void WebviewController::JavascriptCallback(base::Value result) {
+  std::string json;
+  base::JSONWriter::Write(result, &json);
+  std::unique_ptr<webview::WebviewResponse> response =
+      std::make_unique<webview::WebviewResponse>();
+  response->mutable_evaluate_javascript()->set_json(json);
+  client_->EnqueueSend(std::move(response));
+}
+
+void WebviewController::HandleEvaluateJavascript(
+    const webview::EvaluateJavascriptRequest& request) {
+  contents_->GetMainFrame()->ExecuteJavaScript(
+      base::UTF8ToUTF16(request.javascript_blob()),
+      base::BindOnce(&WebviewController::JavascriptCallback,
+                     weak_ptr_factory_.GetWeakPtr()));
+}
+
+void WebviewController::HandleAddJavascriptChannels(
+    const webview::AddJavascriptChannelsRequest& request) {
+  // TODO(dnicoara): Handle this.
+  client_->OnError("Unimplemented add_javascript_channels()");
+}
+
+void WebviewController::HandleRemoveJavascriptChannels(
+    const webview::RemoveJavascriptChannelsRequest& request) {
+  // TODO(dnicoara): Handle this.
+  client_->OnError("Unimplemented remove_javascript_channels()");
+}
+
+void WebviewController::HandleGetCurrentUrl() {
+  std::unique_ptr<webview::WebviewResponse> response =
+      std::make_unique<webview::WebviewResponse>();
+
+  response->mutable_get_current_url()->set_url(contents_->GetURL().spec());
+  client_->EnqueueSend(std::move(response));
+}
+
+void WebviewController::HandleCanGoBack() {
+  std::unique_ptr<webview::WebviewResponse> response =
+      std::make_unique<webview::WebviewResponse>();
+
+  response->mutable_can_go_back()->set_can_go_back(
+      contents_->GetController().CanGoBack());
+  client_->EnqueueSend(std::move(response));
+}
+
+void WebviewController::HandleCanGoForward() {
+  std::unique_ptr<webview::WebviewResponse> response =
+      std::make_unique<webview::WebviewResponse>();
+
+  response->mutable_can_go_forward()->set_can_go_forward(
+      contents_->GetController().CanGoForward());
+  client_->EnqueueSend(std::move(response));
+}
+
+void WebviewController::HandleClearCache() {
+  // TODO(dnicoara): See if there is a generic way to inform the renderer to
+  // clear cache.
+  // Android has a specific renderer message for this:
+  // https://cs.chromium.org/chromium/src/android_webview/common/render_view_messages.h?rcl=65107121555167a3db39de5633c3297f7e861315&l=44
+
+  // Remove disk cache.
+  content::BrowsingDataRemover* remover =
+      content::BrowserContext::GetBrowsingDataRemover(
+          contents_->GetBrowserContext());
+  remover->Remove(base::Time(), base::Time::Max(),
+                  content::BrowsingDataRemover::DATA_TYPE_CACHE,
+                  content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB |
+                      content::BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB);
+}
+
+void WebviewController::HandleGetTitle() {
+  std::unique_ptr<webview::WebviewResponse> response =
+      std::make_unique<webview::WebviewResponse>();
+
+  response->mutable_get_title()->set_title(
+      base::UTF16ToUTF8(contents_->GetTitle()));
+  client_->EnqueueSend(std::move(response));
+}
+
+void WebviewController::HandleUpdateSettings(
+    const webview::UpdateSettingsRequest& request) {
+  content::WebPreferences prefs =
+      contents_->GetRenderViewHost()->GetWebkitPreferences();
+  prefs.javascript_enabled = request.javascript_enabled();
+  contents_->GetRenderViewHost()->UpdateWebkitPreferences(prefs);
+
+  // TODO(dnicoara): Add support for |has_navigation_delegate|.
+
+  // Given that cast_shell enables devtools unconditionally there isn't
+  // anything that needs to be done for |request.debugging_enabled()|. Though,
+  // as a note, remote debugging is always on.
+
+  if (request.has_user_agent() &&
+      request.user_agent().type_case() == webview::UserAgent::kValue) {
+    contents_->SetUserAgentOverride(request.user_agent().value(), true);
+  }
+}
+
+void WebviewController::HandleSetAutoMediaPlaybackPolicy(
+    const webview::SetAutoMediaPlaybackPolicyRequest& request) {
+  content::WebPreferences prefs =
+      contents_->GetRenderViewHost()->GetWebkitPreferences();
+  prefs.autoplay_policy = request.require_user_gesture()
+                              ? content::AutoplayPolicy::kUserGestureRequired
+                              : content::AutoplayPolicy::kNoUserGestureRequired;
+  contents_->GetRenderViewHost()->UpdateWebkitPreferences(prefs);
+}
+
 webview::AsyncPageEvent_State WebviewController::current_state() {
   // The PB enum is defined identically.
   return static_cast<webview::AsyncPageEvent_State>(

chromecast/browser/webview/webview_controller.h

@@ -58,6 +58,21 @@ class WebviewController : public CastWebContents::Delegate,
   webview::AsyncPageEvent_State current_state();
 
   void ProcessInputEvent(const webview::InputEvent& ev);
+  void JavascriptCallback(base::Value result);
+  void HandleEvaluateJavascript(
+      const webview::EvaluateJavascriptRequest& request);
+  void HandleAddJavascriptChannels(
+      const webview::AddJavascriptChannelsRequest& request);
+  void HandleRemoveJavascriptChannels(
+      const webview::RemoveJavascriptChannelsRequest& request);
+  void HandleGetCurrentUrl();
+  void HandleCanGoBack();
+  void HandleCanGoForward();
+  void HandleClearCache();
+  void HandleGetTitle();
+  void HandleUpdateSettings(const webview::UpdateSettingsRequest& request);
+  void HandleSetAutoMediaPlaybackPolicy(
+      const webview::SetAutoMediaPlaybackPolicyRequest& request);
 
   bool Check(bool condition, const char* error);
 
@@ -74,6 +89,8 @@ class WebviewController : public CastWebContents::Delegate,
   std::unique_ptr<CastWebContents> cast_web_contents_;
   bool stopped_ = false;
 
+  base::WeakPtrFactory<WebviewController> weak_ptr_factory_{this};
+
   DISALLOW_COPY_AND_ASSIGN(WebviewController);
 };