reland r57885 with a fix for linux/views.

chrome/browser/tab_contents/tab_contents_view_gtk.cc

 // Copyright (c) 2010 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/tab_contents/tab_contents_view_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
@@ skipping 23 matching lines @@
 #include "gfx/point.h"
 #include "gfx/rect.h"
 #include "gfx/size.h"
 #include "webkit/glue/webdropdata.h"
 
 using WebKit::WebDragOperation;
 using WebKit::WebDragOperationsMask;
 
 namespace {
 
-// Called when the content view gtk widget is tabbed to, or after the call to
-// gtk_widget_child_focus() in TakeFocus(). We return true
-// and grab focus if we don't have it. The call to
-// FocusThroughTabTraversal(bool) forwards the "move focus forward" effect to
-// webkit.
-gboolean OnFocus(GtkWidget* widget, GtkDirectionType focus,
-                 TabContents* tab_contents) {
-  // If we already have focus, let the next widget have a shot at it. We will
-  // reach this situation after the call to gtk_widget_child_focus() in
-  // TakeFocus().
-  if (gtk_widget_is_focus(widget))
-    return FALSE;
-
-  gtk_widget_grab_focus(widget);
-  bool reverse = focus == GTK_DIR_TAB_BACKWARD;
-  tab_contents->FocusThroughTabTraversal(reverse);
-  return TRUE;
-}
-
 // Called when the mouse leaves the widget. We notify our delegate.
 gboolean OnLeaveNotify(GtkWidget* widget, GdkEventCrossing* event,
                        TabContents* tab_contents) {
   if (tab_contents->delegate())
     tab_contents->delegate()->ContentsMouseEvent(
         tab_contents, gfx::Point(event->x_root, event->y_root), false);
   return FALSE;
 }
 
 // Called when the mouse moves within the widget. We notify our delegate.
@@ skipping 85 matching lines @@
     // view twice), we check for the RVH Factory, which will be set when we're
     // making special ones (which go along with the special views).
     DCHECK(RenderViewHostFactory::has_factory());
     return render_widget_host->view();
   }
 
   RenderWidgetHostViewGtk* view =
       new RenderWidgetHostViewGtk(render_widget_host);
   view->InitAsChild();
   gfx::NativeView content_view = view->native_view();
-  g_signal_connect(content_view, "focus",
-                   G_CALLBACK(OnFocus), tab_contents());
+  g_signal_connect(content_view, "focus", G_CALLBACK(OnFocusThunk), this);
   g_signal_connect(content_view, "leave-notify-event",
                    G_CALLBACK(OnLeaveNotify), tab_contents());
   g_signal_connect(content_view, "motion-notify-event",
                    G_CALLBACK(OnMouseMove), tab_contents());
   g_signal_connect(content_view, "scroll-event",
                    G_CALLBACK(OnMouseScroll), tab_contents());
   gtk_widget_add_events(content_view, GDK_LEAVE_NOTIFY_MASK |
                         GDK_POINTER_MOTION_MASK);
   g_signal_connect(content_view, "button-press-event",
                    G_CALLBACK(OnMouseDownThunk), this);
@@ skipping 56 matching lines @@
   // sizing information on to the renderer.
   requested_size_ = size;
   RenderWidgetHostView* rwhv = tab_contents()->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->SetSize(size);
 }
 
 void TabContentsViewGtk::Focus() {
   if (tab_contents()->showing_interstitial_page()) {
     tab_contents()->interstitial_page()->Focus();
-  } else {
+  } else if (!constrained_window_) {
     GtkWidget* widget = GetContentNativeView();
     if (widget)
       gtk_widget_grab_focus(widget);
   }
 }
 
 void TabContentsViewGtk::SetInitialFocus() {
   if (tab_contents()->FocusLocationBarByDefault())
     tab_contents()->SetFocusToLocationBar(false);
   else
     Focus();
 }
 
 void TabContentsViewGtk::StoreFocus() {
   focus_store_.Store(GetNativeView());
 }
 
 void TabContentsViewGtk::RestoreFocus() {
   if (focus_store_.widget())
     gtk_widget_grab_focus(focus_store_.widget());
   else
     SetInitialFocus();
 }
 
+void TabContentsViewGtk::SetFocusedWidget(GtkWidget* widget) {
+  focus_store_.SetWidget(widget);
+}
+
 void TabContentsViewGtk::UpdateDragCursor(WebDragOperation operation) {
   drag_dest_->UpdateDragStatus(operation);
 }
 
 void TabContentsViewGtk::GotFocus() {
   // This is only used in the views FocusManager stuff but it bleeds through
   // all subclasses. http://crbug.com/21875
 }
 
 // This is called when we the renderer asks us to take focus back (i.e., it has
@@ skipping 44 matching lines @@
   drag_source_->StartDragging(drop_data, ops, &last_mouse_down_, image,
                               image_offset);
 }
 
 // -----------------------------------------------------------------------------
 
 void TabContentsViewGtk::InsertIntoContentArea(GtkWidget* widget) {
   gtk_container_add(GTK_CONTAINER(expanded_), widget);
 }
 
+// Called when the content view gtk widget is tabbed to, or after the call to
+// gtk_widget_child_focus() in TakeFocus(). We return true
+// and grab focus if we don't have it. The call to
+// FocusThroughTabTraversal(bool) forwards the "move focus forward" effect to
+// webkit.
+gboolean TabContentsViewGtk::OnFocus(GtkWidget* widget,
+                                     GtkDirectionType focus) {
+  // If we are showing a constrained window, don't allow the native view to take
+  // focus.
+  if (constrained_window_) {
+    // If we return false, it will revert to the default handler, which will
+    // take focus. We don't want that. But if we return true, the event will
+    // stop being propagated, leaving focus wherever it is currently. That is
+    // also bad. So we return false to let the default handler run, but take
+    // focus first so as to trick it into thinking the view was already focused
+    // and allowing the event to propagate.
+    gtk_widget_grab_focus(widget);
+    return FALSE;
+  }
+
+  // If we already have focus, let the next widget have a shot at it. We will
+  // reach this situation after the call to gtk_widget_child_focus() in
+  // TakeFocus().
+  if (gtk_widget_is_focus(widget))
+    return FALSE;
+
+  gtk_widget_grab_focus(widget);
+  bool reverse = focus == GTK_DIR_TAB_BACKWARD;
+  tab_contents()->FocusThroughTabTraversal(reverse);
+  return TRUE;
+}
+
 gboolean TabContentsViewGtk::OnMouseDown(GtkWidget* widget,
                                          GdkEventButton* event) {
   last_mouse_down_ = *event;
   return FALSE;
 }
 
 void TabContentsViewGtk::OnChildSizeRequest(GtkWidget* widget,
                                             GtkWidget* child,
                                             GtkRequisition* requisition) {
   if (tab_contents()->delegate()) {
@@ skipping 41 matching lines @@
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "x", &value);
 
     int child_y = std::max(half_view_height - (requisition.height / 2), 0);
     g_value_set_int(&value, child_y);
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "y", &value);
     g_value_unset(&value);
   }
 }