Connects PostMessage() for OOPIFs

BUG=479172,490221
TEST=none
R=fsamuel@chromium.org

Review URL: https://codereview.chromium.org/1270313006

Cr-Commit-Position: refs/heads/master@{#342939}

17 files changed, 233 insertions, 38 deletions

diff --git a/components/html_viewer/ax_provider_apptest.cc b/components/html_viewer/ax_provider_apptest.cc
index 7add66b..2b77334 100644
--- a/components/html_viewer/ax_provider_apptest.cc
+++ b/components/html_viewer/ax_provider_apptest.cc
@@ -43,8 +43,9 @@ class TestFrameTreeServer : public mandoline::FrameTreeServer {
   ~TestFrameTreeServer() override {}
 
   // mandoline::FrameTreeServer:
-  void PostMessageEventToFrame(uint32_t frame_id,
-                               mandoline::MessageEventPtr event) override {}
+  void PostMessageEventToFrame(uint32_t source_frame_id,
+                               uint32_t target_frame_id,
+                               mandoline::HTMLMessageEventPtr event) override {}
   void LoadingStarted(uint32_t frame_id) override {}
   void LoadingStopped(uint32_t frame_id) override {}
   void ProgressChanged(uint32_t frame_id, double progress) override {}
diff --git a/components/html_viewer/blink_basic_type_converters.cc b/components/html_viewer/blink_basic_type_converters.cc
index f7a5ff4..70a9b8a 100644
--- a/components/html_viewer/blink_basic_type_converters.cc
+++ b/components/html_viewer/blink_basic_type_converters.cc
@@ -24,6 +24,17 @@ WebString TypeConverter<WebString, String>::Convert(const String& str) {
 }
 
 // static
+WebString TypeConverter<WebString, Array<uint8_t>>::Convert(
+    const Array<uint8_t>& input) {
+  COMPILE_ASSERT(sizeof(uint8_t) == sizeof(char),
+                 uint8_t_same_size_as_unsigned_char);
+  return input.is_null()
+             ? WebString()
+             : WebString::fromUTF8(
+                   reinterpret_cast<const char*>(&input.front()), input.size());
+}
+
+// static
 RectPtr TypeConverter<RectPtr, WebRect>::Convert(const WebRect& input) {
   RectPtr result(Rect::New());
   result->x = input.x;
@@ -34,12 +45,15 @@ RectPtr TypeConverter<RectPtr, WebRect>::Convert(const WebRect& input) {
 };
 
 // static
-Array<uint8_t> TypeConverter<Array<uint8_t>, blink::WebString>::Convert(
-    const blink::WebString& input) {
-  std::string utf8 = input.utf8();
+Array<uint8_t> TypeConverter<Array<uint8_t>, WebString>::Convert(
+    const WebString& input) {
+  if (input.isNull())
+    return Array<uint8_t>();
+  const std::string utf8 = input.utf8();
   Array<uint8_t> result(utf8.size());
-  for (size_t i = 0; i < utf8.size(); ++i)
-    result[i] = utf8[i];
+  COMPILE_ASSERT(sizeof(uint8_t) == sizeof(char),
+                 uint8_t_same_size_as_unsigned_char);
+  memcpy(&result.front(), utf8.data(), utf8.size());
   return result.Pass();
 }
 
diff --git a/components/html_viewer/blink_basic_type_converters.h b/components/html_viewer/blink_basic_type_converters.h
index 7eecace..2ccf7f6 100644
--- a/components/html_viewer/blink_basic_type_converters.h
+++ b/components/html_viewer/blink_basic_type_converters.h
@@ -31,6 +31,10 @@ template <>
 struct TypeConverter<Array<uint8_t>, blink::WebString> {
   static Array<uint8_t> Convert(const blink::WebString& input);
 };
+template <>
+struct TypeConverter<blink::WebString, Array<uint8_t>> {
+  static blink::WebString Convert(const Array<uint8_t>& input);
+};
 
 template <>
 struct TypeConverter<RectPtr, blink::WebRect> {
diff --git a/components/html_viewer/document_resource_waiter.cc b/components/html_viewer/document_resource_waiter.cc
index 15029ce..edf0b45 100644
--- a/components/html_viewer/document_resource_waiter.cc
+++ b/components/html_viewer/document_resource_waiter.cc
@@ -9,6 +9,10 @@
 #include "components/html_viewer/html_frame_tree_manager.h"
 #include "components/view_manager/public/cpp/view.h"
 
+#if defined(OS_WIN) && defined(PostMessage)
+#undef PostMessage
+#endif
+
 namespace html_viewer {
 
 DocumentResourceWaiter::DocumentResourceWaiter(GlobalState* global_state,
@@ -89,4 +93,11 @@ void DocumentResourceWaiter::OnFrameClientPropertyChanged(
   NOTREACHED();
 }
 
+void DocumentResourceWaiter::PostMessage(uint32_t source_frame_id,
+                                         uint32_t target_frame_id,
+                                         mandoline::HTMLMessageEventPtr event) {
+  // It is assumed we receive OnConnect() (which unbinds) before anything else.
+  NOTREACHED();
+}
+
 }  // namespace html_viewer
diff --git a/components/html_viewer/document_resource_waiter.h b/components/html_viewer/document_resource_waiter.h
index fd624cc..1a8a74b 100644
--- a/components/html_viewer/document_resource_waiter.h
+++ b/components/html_viewer/document_resource_waiter.h
@@ -57,6 +57,9 @@ class DocumentResourceWaiter : public mandoline::FrameTreeClient {
   void OnFrameClientPropertyChanged(uint32_t frame_id,
                                     const mojo::String& name,
                                     mojo::Array<uint8_t> new_value) override;
+  void PostMessage(uint32_t source_frame_id,
+                   uint32_t target_frame_id,
+                   mandoline::HTMLMessageEventPtr event) override;
 
   GlobalState* global_state_;
   HTMLDocumentOOPIF* document_;
diff --git a/components/html_viewer/html_frame.cc b/components/html_viewer/html_frame.cc
index ceb7a4a..9291e49 100644
--- a/components/html_viewer/html_frame.cc
+++ b/components/html_viewer/html_frame.cc
@@ -46,6 +46,7 @@
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrameWidget.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNavigationPolicy.h"
 #include "third_party/WebKit/public/web/WebRemoteFrame.h"
@@ -61,6 +62,8 @@
 #include "ui/gfx/geometry/size.h"
 #include "url/origin.h"
 
+using mandoline::HTMLMessageEvent;
+using mandoline::HTMLMessageEventPtr;
 using mojo::AxProvider;
 using mojo::Rect;
 using mojo::ServiceProviderPtr;
@@ -574,6 +577,54 @@ void HTMLFrame::OnFrameClientPropertyChanged(uint32_t frame_id,
                                                            new_value.Pass());
 }
 
+void HTMLFrame::PostMessage(uint32_t source_frame_id,
+                            uint32_t target_frame_id,
+                            HTMLMessageEventPtr serialized_event) {
+  NOTIMPLEMENTED();  // For message ports.
+
+  HTMLFrame* target = frame_tree_manager_->root_->FindFrame(target_frame_id);
+  HTMLFrame* source = frame_tree_manager_->root_->FindFrame(source_frame_id);
+  if (!target || !source) {
+    DVLOG(1) << "Invalid source or target for PostMessage";
+    return;
+  }
+
+  if (!target->IsLocal()) {
+    DVLOG(1) << "Target for PostMessage is not lot local";
+    return;
+  }
+
+  blink::WebFrame* target_web_frame = target->web_frame_;
+
+  blink::WebSerializedScriptValue serialized_script_value;
+  serialized_script_value = blink::WebSerializedScriptValue::fromString(
+      serialized_event->data.To<blink::WebString>());
+
+  blink::WebMessagePortChannelArray channels;
+
+  // Create an event with the message.  The next-to-last parameter to
+  // initMessageEvent is the last event ID, which is not used with postMessage.
+  blink::WebDOMEvent event =
+      target_web_frame->document().createEvent("MessageEvent");
+  blink::WebDOMMessageEvent msg_event = event.to<blink::WebDOMMessageEvent>();
+  msg_event.initMessageEvent(
+      "message",
+      // |canBubble| and |cancellable| are always false
+      false, false, serialized_script_value,
+      serialized_event->source_origin.To<blink::WebString>(),
+      source->web_frame_, "", channels);
+
+  // We must pass in the target_origin to do the security check on this side,
+  // since it may have changed since the original postMessage call was made.
+  blink::WebSecurityOrigin target_origin;
+  if (!serialized_event->target_origin.is_null()) {
+    target_origin = blink::WebSecurityOrigin::createFromString(
+        serialized_event->target_origin.To<blink::WebString>());
+  }
+  target_web_frame->dispatchMessageEventWithOriginCheck(target_origin,
+                                                        msg_event);
+}
+
 blink::WebStorageNamespace* HTMLFrame::createSessionStorageNamespace() {
   return new WebStorageNamespaceImpl();
 }
@@ -830,11 +881,27 @@ void HTMLFrame::UpdateTextInputState(bool show_ime) {
   }
 }
 
-void HTMLFrame::postMessageEvent(blink::WebLocalFrame* source_frame,
-                                 blink::WebRemoteFrame* target_frame,
+void HTMLFrame::postMessageEvent(blink::WebLocalFrame* source_web_frame,
+                                 blink::WebRemoteFrame* target_web_frame,
                                  blink::WebSecurityOrigin target_origin,
-                                 blink::WebDOMMessageEvent event) {
-  NOTIMPLEMENTED();
+                                 blink::WebDOMMessageEvent web_event) {
+  NOTIMPLEMENTED();  // message_ports aren't implemented yet.
+
+  HTMLFrame* source_frame =
+      frame_tree_manager_->root_->FindFrameWithWebFrame(source_web_frame);
+  DCHECK(source_frame);
+  HTMLFrame* target_frame =
+      frame_tree_manager_->root_->FindFrameWithWebFrame(target_web_frame);
+  DCHECK(target_frame);
+
+  HTMLMessageEventPtr event(HTMLMessageEvent::New());
+  event->data = mojo::Array<uint8_t>::From(web_event.data().toString());
+  event->source_origin = mojo::String::From(web_event.origin());
+  if (!target_origin.isNull())
+    event->target_origin = mojo::String::From(target_origin.toString());
+
+  GetFrameTreeServer()->PostMessageEventToFrame(
+      source_frame->id_, target_frame->id_, event.Pass());
 }
 
 void HTMLFrame::initializeChildFrame(const blink::WebRect& frame_rect,
diff --git a/components/html_viewer/html_frame.h b/components/html_viewer/html_frame.h
index ad2a806..c4fc825 100644
--- a/components/html_viewer/html_frame.h
+++ b/components/html_viewer/html_frame.h
@@ -197,6 +197,9 @@ class HTMLFrame : public blink::WebFrameClient,
   void OnFrameClientPropertyChanged(uint32_t frame_id,
                                     const mojo::String& name,
                                     mojo::Array<uint8_t> new_value) override;
+  void PostMessage(uint32_t source_frame_id,
+                   uint32_t target_frame_id,
+                   mandoline::HTMLMessageEventPtr serialized_event) override;
 
   // WebViewClient methods:
   virtual blink::WebStorageNamespace* createSessionStorageNamespace();
@@ -251,8 +254,8 @@ class HTMLFrame : public blink::WebFrameClient,
 
   // blink::WebRemoteFrameClient:
   virtual void frameDetached(blink::WebRemoteFrameClient::DetachType type);
-  virtual void postMessageEvent(blink::WebLocalFrame* source_frame,
-                                blink::WebRemoteFrame* target_frame,
+  virtual void postMessageEvent(blink::WebLocalFrame* source_web_frame,
+                                blink::WebRemoteFrame* target_web_frame,
                                 blink::WebSecurityOrigin target_origin,
                                 blink::WebDOMMessageEvent event);
   virtual void initializeChildFrame(const blink::WebRect& frame_rect,
diff --git a/components/html_viewer/html_frame_apptest.cc b/components/html_viewer/html_frame_apptest.cc
index c98053e..55688fc 100644
--- a/components/html_viewer/html_frame_apptest.cc
+++ b/components/html_viewer/html_frame_apptest.cc
@@ -86,10 +86,10 @@ class HTMLFrameTest : public ViewManagerTestBase {
  protected:
   // Creates the frame tree showing an empty page at the root and adds (via
   // script) a frame showing the same empty page.
-  Frame* LoadEmptyPageAndCreateFrame() {
+  Frame* LoadEmptyPageAndCreateFrame(mandoline::FrameTreeDelegate* delegate) {
     View* embed_view = window_manager()->CreateView();
     FrameConnection* root_connection = InitFrameTree(
-        embed_view, nullptr, "http://127.0.0.1:%u/files/empty_page2.html");
+        embed_view, delegate, "http://127.0.0.1:%u/files/empty_page2.html");
     const std::string frame_text =
         GetFrameText(root_connection->application_connection());
     if (frame_text != "child2") {
@@ -329,7 +329,7 @@ TEST_F(HTMLFrameTest, DynamicallyAddFrameAndVerifyParent) {
   if (!EnableOOPIFs())
     return;
 
-  Frame* child_frame = LoadEmptyPageAndCreateFrame();
+  Frame* child_frame = LoadEmptyPageAndCreateFrame(nullptr);
   ASSERT_TRUE(child_frame);
 
   mojo::ApplicationConnection* child_frame_connection =
@@ -354,7 +354,7 @@ TEST_F(HTMLFrameTest, DynamicallyAddFrameAndSeeNameChange) {
   if (!EnableOOPIFs())
     return;
 
-  Frame* child_frame = LoadEmptyPageAndCreateFrame();
+  Frame* child_frame = LoadEmptyPageAndCreateFrame(nullptr);
   ASSERT_TRUE(child_frame);
 
   mojo::ApplicationConnection* child_frame_connection =
@@ -393,7 +393,7 @@ TEST_F(HTMLFrameTest, FrameTreeOfThreeLevels) {
     return;
 
   // Create a child frame, and in that child frame create another child frame.
-  Frame* child_frame = LoadEmptyPageAndCreateFrame();
+  Frame* child_frame = LoadEmptyPageAndCreateFrame(nullptr);
   ASSERT_TRUE(child_frame);
 
   ASSERT_TRUE(CreateEmptyChildFrame(child_frame));
@@ -447,4 +447,52 @@ TEST_F(HTMLFrameTest, FrameTreeOfThreeLevels) {
   ASSERT_EQ("0", child_child_frame_count);
 }
 
+// Verifies PostMessage() works across frames.
+TEST_F(HTMLFrameTest, PostMessage) {
+  if (!EnableOOPIFs())
+    return;
+
+  mandoline::TestFrameTreeDelegate frame_tree_delegate;
+  Frame* child_frame = LoadEmptyPageAndCreateFrame(&frame_tree_delegate);
+  ASSERT_TRUE(child_frame);
+
+  mojo::ApplicationConnection* child_frame_connection =
+      ApplicationConnectionForFrame(child_frame);
+  ASSERT_EQ("child", GetFrameText(child_frame_connection));
+
+  // Register an event handler in the child frame.
+  const char kRegisterPostMessageHandler[] =
+      "window.messageData = null;"
+      "function messageFunction(event) {"
+      "  window.messageData = event.data;"
+      "}"
+      "window.addEventListener('message', messageFunction, false);";
+  ExecuteScript(child_frame_connection, kRegisterPostMessageHandler);
+
+  // Post a message from the parent to the child.
+  const char kPostMessageFromParent[] =
+      "window.frames[0].postMessage('hello from parent', '*');";
+  ExecuteScript(ApplicationConnectionForFrame(frame_tree_->root()),
+                kPostMessageFromParent);
+
+  // Wait for the child frame to see the message.
+  const base::TimeTicks start_time(base::TimeTicks::Now());
+  std::string message_in_child;
+  do {
+    const char kGetMessageData[] = "window.messageData;";
+    scoped_ptr<base::Value> script_value(
+        ExecuteScript(child_frame_connection, kGetMessageData));
+    if (script_value->IsType(base::Value::TYPE_LIST)) {
+      base::ListValue* script_value_as_list;
+      if (script_value->GetAsList(&script_value_as_list) &&
+          script_value_as_list->GetSize() == 1) {
+        script_value_as_list->GetString(0u, &message_in_child);
+      }
+    }
+  } while (message_in_child != "hello from parent" &&
+           base::TimeTicks::Now() - start_time <
+               TestTimeouts::action_timeout());
+  EXPECT_EQ("hello from parent", message_in_child);
+}
+
 }  // namespace mojo
diff --git a/mandoline/tab/frame.cc b/mandoline/tab/frame.cc
index b120c93..6e1613d 100644
--- a/mandoline/tab/frame.cc
+++ b/mandoline/tab/frame.cc
@@ -171,6 +171,13 @@ void Frame::SetView(mojo::View* view) {
   view_->AddObserver(this);
 }
 
+Frame* Frame::GetAncestorWithFrameTreeClient() {
+  Frame* frame = this;
+  while (frame && !frame->frame_tree_client_)
+    frame = frame->parent_;
+  return frame;
+}
+
 void Frame::BuildFrameTree(std::vector<const Frame*>* frames) const {
   frames->push_back(this);
   for (const Frame* frame : children_)
@@ -307,13 +314,19 @@ void Frame::OnViewDestroying(mojo::View* view) {
   delete this;
 }
 
-void Frame::PostMessageEventToFrame(uint32_t frame_id, MessageEventPtr event) {
-  Frame* target = tree_->root()->FindFrame(frame_id);
-  if (!target ||
-      !tree_->delegate_->CanPostMessageEventToFrame(this, target, event.get()))
+void Frame::PostMessageEventToFrame(uint32_t source_frame_id,
+                                    uint32_t target_frame_id,
+                                    HTMLMessageEventPtr event) {
+  Frame* source = tree_->root()->FindFrame(source_frame_id);
+  Frame* target = tree_->root()->FindFrame(target_frame_id);
+  if (!target || !source || source == target || !tree_->delegate_ ||
+      !tree_->delegate_->CanPostMessageEventToFrame(source, target,
+                                                    event.get()))
     return;
 
-  NOTIMPLEMENTED();
+  DCHECK(target->GetAncestorWithFrameTreeClient());
+  target->GetAncestorWithFrameTreeClient()->frame_tree_client_->PostMessage(
+      source_frame_id, target_frame_id, event.Pass());
 }
 
 void Frame::LoadingStarted(uint32_t frame_id) {
diff --git a/mandoline/tab/frame.h b/mandoline/tab/frame.h
index 8d051fe..7848767 100644
--- a/mandoline/tab/frame.h
+++ b/mandoline/tab/frame.h
@@ -103,6 +103,10 @@ class Frame : public mojo::ViewObserver, public FrameTreeServer {
 
   void SetView(mojo::View* view);
 
+  // Returns the first ancestor (starting at |this|) that has a
+  // FrameTreeClient.
+  Frame* GetAncestorWithFrameTreeClient();
+
   // Adds this to |frames| and recurses through the children calling the
   // same function.
   void BuildFrameTree(std::vector<const Frame*>* frames) const;
@@ -138,8 +142,9 @@ class Frame : public mojo::ViewObserver, public FrameTreeServer {
   void OnViewDestroying(mojo::View* view) override;
 
   // FrameTreeServer:
-  void PostMessageEventToFrame(uint32_t frame_id,
-                               MessageEventPtr event) override;
+  void PostMessageEventToFrame(uint32_t source_frame_id,
+                               uint32_t target_frame_id,
+                               HTMLMessageEventPtr event) override;
   void LoadingStarted(uint32_t frame_id) override;
   void LoadingStopped(uint32_t frame_id) override;
   void ProgressChanged(uint32_t frame_id, double progress) override;
diff --git a/mandoline/tab/frame_apptest.cc b/mandoline/tab/frame_apptest.cc
index 32685a7..8d7c746 100644
--- a/mandoline/tab/frame_apptest.cc
+++ b/mandoline/tab/frame_apptest.cc
@@ -153,6 +153,9 @@ class TestFrameTreeClient : public FrameTreeClient {
   void OnFrameClientPropertyChanged(uint32_t frame_id,
                                     const mojo::String& name,
                                     mojo::Array<uint8_t> new_data) override {}
+  void PostMessage(uint32_t source_frame_id,
+                   uint32_t target_frame_id,
+                   HTMLMessageEventPtr event) override {}
 
  private:
   int connect_count_;
diff --git a/mandoline/tab/frame_tree_delegate.h b/mandoline/tab/frame_tree_delegate.h
index 6562bd8..b72446a 100644
--- a/mandoline/tab/frame_tree_delegate.h
+++ b/mandoline/tab/frame_tree_delegate.h
@@ -11,13 +11,16 @@
 namespace mandoline {
 
 class Frame;
-class MessageEvent;
+class HTMLMessageEvent;
 
 class FrameTreeDelegate {
  public:
+  // Returns whether a request to post a message from |source| to |target|
+  // is allowed. |source| and |target| are never null.
   virtual bool CanPostMessageEventToFrame(const Frame* source,
                                           const Frame* target,
-                                          MessageEvent* event) = 0;
+                                          HTMLMessageEvent* event) = 0;
+
   virtual void LoadingStateChanged(bool loading) = 0;
   virtual void ProgressChanged(double progress) = 0;
 
diff --git a/mandoline/tab/public/interfaces/frame_tree.mojom b/mandoline/tab/public/interfaces/frame_tree.mojom
index f49612c..245c521 100644
--- a/mandoline/tab/public/interfaces/frame_tree.mojom
+++ b/mandoline/tab/public/interfaces/frame_tree.mojom
@@ -48,13 +48,28 @@ struct FrameData {
   map<string, array<uint8>>? client_properties;
 };
 
-struct MessageEvent {
-  // TODO(sky): add details.
+// TODO(sky): decide which bits of this make sense for all frames, and move the
+// html specific parts into properties.
+struct HTMLMessageEvent {
+  // The serialized script value.
+  array<uint8>? data;
+
+  // The origin of the source frame.
+  string source_origin;
+
+  // The origin for the message's target.
+  string? target_origin;
+
+  // TODO(sky): these two are not implemented. Figure out what they should be.
+  // Information about the MessagePorts this message contains.
+  // IPC_STRUCT_MEMBER(std::vector<content::TransferredMessagePort>, message_ports)
+  // IPC_STRUCT_MEMBER(std::vector<int>, new_routing_ids)
 };
 
 interface FrameTreeServer {
-  // TODO(sky): make these real.
-  PostMessageEventToFrame(uint32 frame_id, MessageEvent event);
+  PostMessageEventToFrame(uint32 source_frame_id,
+                          uint32 target_frame_id,
+                          HTMLMessageEvent event);
 
   // Notifies the server that a load has started or stopped in this frame.
   // When loading is started, progress is reset to 0, but when loading is
@@ -108,4 +123,8 @@ interface FrameTreeClient {
   OnFrameClientPropertyChanged(uint32 frame_id,
                                string name,
                                array<uint8>? new_value);
+
+  PostMessage(uint32 source_frame_id,
+              uint32 target_frame_id,
+              HTMLMessageEvent event);
 };
diff --git a/mandoline/tab/test_frame_tree_delegate.cc b/mandoline/tab/test_frame_tree_delegate.cc
index 2f26e40..045a1b6 100644
--- a/mandoline/tab/test_frame_tree_delegate.cc
+++ b/mandoline/tab/test_frame_tree_delegate.cc
@@ -10,10 +10,11 @@ TestFrameTreeDelegate::TestFrameTreeDelegate() {}
 
 TestFrameTreeDelegate::~TestFrameTreeDelegate() {}
 
-bool TestFrameTreeDelegate::CanPostMessageEventToFrame(const Frame* source,
-                                                       const Frame* target,
-                                                       MessageEvent* event) {
-  return false;
+bool TestFrameTreeDelegate::CanPostMessageEventToFrame(
+    const Frame* source,
+    const Frame* target,
+    HTMLMessageEvent* event) {
+  return true;
 }
 
 void TestFrameTreeDelegate::LoadingStateChanged(bool loading) {}
diff --git a/mandoline/tab/test_frame_tree_delegate.h b/mandoline/tab/test_frame_tree_delegate.h
index 5b8c24a..d7ea74e 100644
--- a/mandoline/tab/test_frame_tree_delegate.h
+++ b/mandoline/tab/test_frame_tree_delegate.h
@@ -18,7 +18,7 @@ class TestFrameTreeDelegate : public FrameTreeDelegate {
   // TestFrameTreeDelegate:
   bool CanPostMessageEventToFrame(const Frame* source,
                                   const Frame* target,
-                                  MessageEvent* event) override;
+                                  HTMLMessageEvent* event) override;
   void LoadingStateChanged(bool loading) override;
   void ProgressChanged(double progress) override;
   void RequestNavigate(Frame* source,
diff --git a/mandoline/ui/browser/browser.cc b/mandoline/ui/browser/browser.cc
index c6114d6..15ab1f2 100644
--- a/mandoline/ui/browser/browser.cc
+++ b/mandoline/ui/browser/browser.cc
@@ -186,7 +186,7 @@ void Browser::Embed(mojo::URLRequestPtr request) {
 
 bool Browser::CanPostMessageEventToFrame(const Frame* source,
                                          const Frame* target,
-                                         MessageEvent* event) {
+                                         HTMLMessageEvent* event) {
   return true;
 }
 
diff --git a/mandoline/ui/browser/browser.h b/mandoline/ui/browser/browser.h
index 5c44389..dcca090 100644
--- a/mandoline/ui/browser/browser.h
+++ b/mandoline/ui/browser/browser.h
@@ -84,7 +84,7 @@ class Browser : public mojo::ViewManagerDelegate,
   // Overridden from FrameTreeDelegate:
   bool CanPostMessageEventToFrame(const Frame* source,
                                   const Frame* target,
-                                  MessageEvent* event) override;
+                                  HTMLMessageEvent* event) override;
   void LoadingStateChanged(bool loading) override;
   void ProgressChanged(double progress) override;
   void RequestNavigate(Frame* source,