BrowserPlugin: Interstitial Pages work

content/browser/frame_host/render_widget_host_view_guest.cc

 // Copyright 2014 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 "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/browser_plugin/browser_plugin_guest.h"
 #include "content/browser/frame_host/render_widget_host_view_guest.h"
@@ skipping 68 matching lines @@
 void RenderWidgetHostViewGuest::WasShown() {
   // If the WebContents associated with us showed an interstitial page in the
   // beginning, the teardown path might call WasShown() while |host_| is in
   // the process of destruction. Avoid calling WasShown below in this case.
   // TODO(lazyboy): We shouldn't be showing interstitial pages in guests in the
   // first place: http://crbug.com/273089.
   //
   // |guest_| is NULL during test.
   if ((guest_ && guest_->is_in_destruction()) || !host_->is_hidden())
     return;
+  // Make sure the size of this view matches the size of the WebContentsView.
+  // The two sizes may fall out of sync if we switch RenderWidgetHostViews,
+  // resize, and then switch page, as is the case with interstitial pages.
+  // NOTE: |guest_| is NULL in unit tests.
+  if (guest_)
+    SetSize(guest_->web_contents()->GetViewBounds().size());
   host_->WasShown(ui::LatencyInfo());
 }
 
 void RenderWidgetHostViewGuest::WasHidden() {
   // |guest_| is NULL during test.
   if ((guest_ && guest_->is_in_destruction()) || host_->is_hidden())
     return;
   host_->WasHidden();
 }
 
 void RenderWidgetHostViewGuest::SetSize(const gfx::Size& size) {
   size_ = size;
   host_->WasResized();
 }
 
 void RenderWidgetHostViewGuest::SetBounds(const gfx::Rect& rect) {
   SetSize(rect.size());
 }
 
+void RenderWidgetHostViewGuest::Focus() {
+  // InterstitialPageImpl focuses views directly, so we place focus logic here.
+  // InterstitialPages are not WebContents, and so BrowserPluginGuest does not
+  // have direct access to the interstitial page's RenderWidgetHost.
+  if (guest_)
+    guest_->SetFocus(host_, true);
+}
+
+bool RenderWidgetHostViewGuest::HasFocus() const {
+  if (!guest_)
+    return false;
+  return guest_->focused();
+}
+
 #if defined(USE_AURA)
 void RenderWidgetHostViewGuest::ProcessAckedTouchEvent(
     const TouchEventWithLatencyInfo& touch, InputEventAckState ack_result) {
   // TODO(fsamuel): Currently we will only take this codepath if the guest has
   // requested touch events. A better solution is to always forward touchpresses
   // to the embedder process to target a BrowserPlugin, and then route all
   // subsequent touch points of that touchdown to the appropriate guest until
   // that touch point is released.
   ScopedVector<ui::TouchEvent> events;
   if (!MakeUITouchEventsFromWebTouchEvents(touch, &events, LOCAL_COORDINATES))
@@ skipping 141 matching lines @@
     return gfx::NativeViewAccessible();
   return rwhv->GetNativeViewAccessible();
 }
 
 void RenderWidgetHostViewGuest::MovePluginWindows(
     const std::vector<WebPluginGeometry>& moves) {
   platform_view_->MovePluginWindows(moves);
 }
 
 void RenderWidgetHostViewGuest::UpdateCursor(const WebCursor& cursor) {
-  platform_view_->UpdateCursor(cursor);
+  // InterstitialPages are not WebContents so we cannot intercept
+  // ViewHostMsg_SetCursor for interstitial pages in BrowserPluginGuest.
+  // All guest RenderViewHosts have RenderWidgetHostViewGuests however,
+  // and so we will always hit this code path.
+  if (!guest_)
+    return;
+  guest_->SendMessageToEmbedder(
+      new BrowserPluginMsg_SetCursor(guest_->browser_plugin_instance_id(),
+                                     cursor));
+
 }
 
 void RenderWidgetHostViewGuest::SetIsLoading(bool is_loading) {
   platform_view_->SetIsLoading(is_loading);
 }
 
 void RenderWidgetHostViewGuest::TextInputStateChanged(
     const ViewHostMsg_TextInputState_Params& params) {
   if (!guest_)
     return;
@@ skipping 276 matching lines @@
 
   if (event->type == blink::WebInputEvent::MouseWheel) {
     host_->ForwardWheelEvent(
         *static_cast<const blink::WebMouseWheelEvent*>(event));
     return;
   }
 
   if (blink::WebInputEvent::isKeyboardEventType(event->type)) {
     if (!embedder->GetLastKeyboardEvent())
       return;
-    NativeWebKeyboardEvent keyboard_event(
-        *embedder->GetLastKeyboardEvent());
+    NativeWebKeyboardEvent keyboard_event(*embedder->GetLastKeyboardEvent());
     host_->ForwardKeyboardEvent(keyboard_event);
     return;
   }
 
   if (blink::WebInputEvent::isTouchEventType(event->type)) {
     host_->ForwardTouchEventWithLatencyInfo(
         *static_cast<const blink::WebTouchEvent*>(event),
         ui::LatencyInfo());
     return;
   }
 
   if (blink::WebInputEvent::isGestureEventType(event->type)) {
     host_->ForwardGestureEvent(
         *static_cast<const blink::WebGestureEvent*>(event));
     return;
   }
 }
 
 }  // namespace content