Re-land:

views/widget/widget_gtk.cc

 // Copyright (c) 2011 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 "views/widget/widget_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <X11/extensions/shape.h>
 #include <X11/Xatom.h>
@@ skipping 266 matching lines @@
   return drag_widget;
 }
 
 // static
 GtkWidget* WidgetGtk::null_parent_ = NULL;
 bool WidgetGtk::debug_paint_enabled_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, public:
 
-WidgetGtk::WidgetGtk()
+WidgetGtk::WidgetGtk(internal::NativeWidgetDelegate* delegate)
     : is_window_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(delegate_(this)),
+      delegate_(delegate),
       widget_(NULL),
       window_contents_(NULL),
       child_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(close_widget_factory_(this)),
       delete_on_destroy_(true),
       transparent_(false),
       ignore_events_(false),
       ignore_drag_leave_(false),
       opacity_(255),
       drag_data_(NULL),
       is_active_(false),
       transient_to_parent_(false),
       got_initial_focus_in_(false),
       has_focus_(false),
+      focus_on_creation_(true),
       always_on_top_(false),
       is_double_buffered_(false),
       should_handle_menu_key_release_(false),
       dragged_view_(NULL),
       painted_(false) {
 #if defined(TOUCH_UI) && defined(HAVE_XINPUT2)
   // Make sure the touch factory is initialized so that it can setup XInput2 for
   // the widget.
   TouchFactory::GetInstance();
 #endif
-  set_native_widget(this);
   static bool installed_message_loop_observer = false;
   if (!installed_message_loop_observer) {
     installed_message_loop_observer = true;
     MessageLoopForUI* loop = MessageLoopForUI::current();
     if (loop)
       loop->AddObserver(DropObserver::GetInstance());
   }
 }
 
 WidgetGtk::~WidgetGtk() {
   // We need to delete the input method before calling DestroyRootView(),
   // because it'll set focus_manager_ to NULL.
   input_method_.reset();
-  DestroyRootView();
   DCHECK(delete_on_destroy_ || widget_ == NULL);
+  if (delete_on_destroy_)
+    delete delegate_;
 }
 
 GtkWindow* WidgetGtk::GetTransientParent() const {
   return (!child_ && widget_) ?
       gtk_window_get_transient_for(GTK_WINDOW(widget_)) : NULL;
 }
 
 bool WidgetGtk::MakeTransparent() {
   // Transparency can only be enabled only if we haven't realized the widget.
   DCHECK(!widget_);
@@ skipping 96 matching lines @@
 
   drag_data_ = NULL;
 
   if (drag_icon_widget) {
     gtk_widget_destroy(drag_icon_widget);
     g_object_unref(provider.drag_image());
   }
 }
 
 void WidgetGtk::IsActiveChanged() {
-  WidgetDelegate* d = widget_delegate();
+  WidgetDelegate* d = GetWidget()->widget_delegate();
   if (d) {
     bool a = IsActive();
     d->OnWidgetActivated(a);
   }
 }
 
 void WidgetGtk::SetInitialFocus() {
-  View* v = widget_delegate() ?
-      widget_delegate()->GetInitiallyFocusedView() : NULL;
+  if (!focus_on_creation_)
+    return;
+
+  View* v = GetWidget()->widget_delegate() ?
+      GetWidget()->widget_delegate()->GetInitiallyFocusedView() : NULL;
   if (v)
     v->RequestFocus();
 }
 
 void WidgetGtk::ResetDropTarget() {
   ignore_drag_leave_ = false;
   drop_target_.reset(NULL);
 }
 
 void WidgetGtk::GetRequestedSize(gfx::Size* out) const {
@@ skipping 23 matching lines @@
     gpointer data = NULL;
     gdk_window_get_user_data(active_window, &data);
     GtkWidget* widget = reinterpret_cast<GtkWidget*>(data);
     is_active_ =
         (widget && GTK_IS_WINDOW(widget) &&
          gtk_window_get_transient_for(GTK_WINDOW(widget)) == GTK_WINDOW(
              widget_));
   }
   if (was_active != IsActive()) {
     IsActiveChanged();
-    GetRootView()->SchedulePaint();
+    GetWidget()->GetRootView()->SchedulePaint();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, Widget implementation:
 
-gfx::NativeView WidgetGtk::GetNativeView() const {
-  return widget_;
-}
-
-gfx::NativeWindow WidgetGtk::GetNativeWindow() const {
-  return child_ ? NULL : GTK_WINDOW(widget_);
-}
-
-bool WidgetGtk::GetAccelerator(int cmd_id, ui::Accelerator* accelerator) {
-  NOTIMPLEMENTED();
-  return false;
-}
-
-Window* WidgetGtk::GetWindow() {
-  return GetWindowImpl(widget_);
-}
-
-const Window* WidgetGtk::GetWindow() const {
-  return GetWindowImpl(widget_);
-}
-
-void WidgetGtk::ViewHierarchyChanged(bool is_add, View* parent, View* child) {
-  Widget::ViewHierarchyChanged(is_add, parent, child);
-  if (drop_target_.get())
-    drop_target_->ResetTargetViewIfEquals(child);
-}
-
-void WidgetGtk::NotifyAccessibilityEvent(
-    View* view,
-    ui::AccessibilityTypes::Event event_type,
-    bool send_native_event) {
-  // Send the notification to the delegate.
-  if (ViewsDelegate::views_delegate)
-    ViewsDelegate::views_delegate->NotifyAccessibilityEvent(view, event_type);
-
-  // In the future if we add native GTK accessibility support, the
-  // notification should be sent here.
-}
-
 void WidgetGtk::ClearNativeFocus() {
   DCHECK(!child_);
   if (!GetNativeView()) {
     NOTREACHED();
     return;
   }
   gtk_window_set_focus(GTK_WINDOW(GetNativeView()), NULL);
 }
 
 bool WidgetGtk::HandleKeyboardEvent(const KeyEvent& key) {
-  if (!GetFocusManager())
+  if (!GetWidget()->GetFocusManager())
     return false;
 
   const int key_code = key.key_code();
   bool handled = false;
 
   // Always reset |should_handle_menu_key_release_| unless we are handling a
   // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
   // be activated when handling a VKEY_MENU key release event which is preceded
   // by an un-handled VKEY_MENU key press event.
   if (key_code != ui::VKEY_MENU || key.type() != ui::ET_KEY_RELEASED)
     should_handle_menu_key_release_ = false;
 
   if (key.type() == ui::ET_KEY_PRESSED) {
     // VKEY_MENU is triggered by key release event.
     // FocusManager::OnKeyEvent() returns false when the key has been consumed.
     if (key_code != ui::VKEY_MENU)
-      handled = !GetFocusManager()->OnKeyEvent(key);
+      handled = !GetWidget()->GetFocusManager()->OnKeyEvent(key);
     else
       should_handle_menu_key_release_ = true;
   } else if (key_code == ui::VKEY_MENU && should_handle_menu_key_release_ &&
              (key.flags() & ~ui::EF_ALT_DOWN) == 0) {
     // Trigger VKEY_MENU when only this key is pressed and released, and both
     // press and release events are not handled by others.
     Accelerator accelerator(ui::VKEY_MENU, false, false, false);
-    handled = GetFocusManager()->ProcessAccelerator(accelerator);
+    handled = GetWidget()->GetFocusManager()->ProcessAccelerator(accelerator);
   }
 
   return handled;
 }
 
 // static
 void WidgetGtk::EnableDebugPaint() {
   debug_paint_enabled_ = true;
 }
 
@@ skipping 28 matching lines @@
   RemoveExposeHandlerIfExists(child);
   gulong id = g_signal_connect_after(child, "expose-event",
                                      G_CALLBACK(&ChildExposeHandler), NULL);
   g_object_set_data(G_OBJECT(child), kExposeHandlerIdKey,
                     reinterpret_cast<void*>(id));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, NativeWidget implementation:
 
-void WidgetGtk::InitNativeWidget(const InitParams& params) {
+void WidgetGtk::InitNativeWidget(const Widget::InitParams& params) {
   SetInitParams(params);
 
-  InitParams modified_params = params;
+  Widget::InitParams modified_params = params;
   gfx::NativeView parent = params.parent;
   if (params.parent_widget) {
     WidgetGtk* parent_gtk =
         static_cast<WidgetGtk*>(params.parent_widget->native_widget());
     modified_params.parent = child_ ? parent_gtk->window_contents()
                                     : params.parent_widget->GetNativeView();
   }
 
   if (!child_)
     ActiveWindowWatcherX::AddObserver(this);
@@ skipping 116 matching lines @@
       SetBounds(params.bounds);
   } else {
     if (params.bounds.width() > 0 && params.bounds.height() > 0)
       gtk_window_resize(GTK_WINDOW(widget_), params.bounds.width(),
                         params.bounds.height());
     gtk_window_move(GTK_WINDOW(widget_), params.bounds.x(), params.bounds.y());
   }
 }
 
 Widget* WidgetGtk::GetWidget() {
-  return this;
+  return delegate_->AsWidget();
+}
+
+const Widget* WidgetGtk::GetWidget() const {
+  return delegate_->AsWidget();
+}
+
+gfx::NativeView WidgetGtk::GetNativeView() const {
+  return widget_;
+}
+
+gfx::NativeWindow WidgetGtk::GetNativeWindow() const {
+  return child_ ? NULL : GTK_WINDOW(widget_);
+}
+
+Window* WidgetGtk::GetContainingWindow() {
+  return GetWindowImpl(widget_);
+}
+
+const Window* WidgetGtk::GetContainingWindow() const {
+  return GetWindowImpl(widget_);
+}
+
+void WidgetGtk::ViewRemoved(View* view) {
+  if (drop_target_.get())
+    drop_target_->ResetTargetViewIfEquals(view);
 }
 
 void WidgetGtk::SetNativeWindowProperty(const char* name, void* value) {
   g_object_set_data(G_OBJECT(widget_), name, value);
 }
 
 void* WidgetGtk::GetNativeWindowProperty(const char* name) {
   return g_object_get_data(G_OBJECT(widget_), name);
 }
 
 TooltipManager* WidgetGtk::GetTooltipManager() const {
   return tooltip_manager_.get();
 }
 
 bool WidgetGtk::IsScreenReaderActive() const {
   return false;
 }
 
+void WidgetGtk::SendNativeAccessibilityEvent(
+    View* view,
+    ui::AccessibilityTypes::Event event_type) {
+  // In the future if we add native GTK accessibility support, the
+  // notification should be sent here.
+}
+
 void WidgetGtk::SetMouseCapture() {
   DCHECK(!HasMouseCapture());
   gtk_grab_add(window_contents_);
 }
 
 void WidgetGtk::ReleaseMouseCapture() {
   if (HasMouseCapture())
     gtk_grab_remove(window_contents_);
 }
 
 bool WidgetGtk::HasMouseCapture() const {
   // TODO(beng): Should be able to use gtk_widget_has_grab() here but the
   //             trybots don't have Gtk 2.18.
   return GTK_WIDGET_HAS_GRAB(window_contents_);
 }
 
+bool WidgetGtk::IsMouseButtonDown() const {
+  bool button_pressed = false;
+  GdkEvent* event = gtk_get_current_event();
+  if (event) {
+    button_pressed = event->type == GDK_BUTTON_PRESS ||
+        event->type == GDK_2BUTTON_PRESS ||
+        event->type == GDK_3BUTTON_PRESS;
+    gdk_event_free(event);
+  }
+  return button_pressed;
+}
+
 InputMethod* WidgetGtk::GetInputMethodNative() {
   return input_method_.get();
 }
 
 void WidgetGtk::ReplaceInputMethod(InputMethod* input_method) {
   input_method_.reset(input_method);
   if (input_method) {
     input_method->set_delegate(this);
     input_method->Init(GetWidget());
   }
@@ skipping 197 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, protected:
 
 void WidgetGtk::OnSizeRequest(GtkWidget* widget, GtkRequisition* requisition) {
   // Do only return the preferred size for child windows. GtkWindow interprets
   // the requisition as a minimum size for top level windows, returning a
   // preferred size for these would prevents us from setting smaller window
   // sizes.
   if (child_) {
-    gfx::Size size(GetRootView()->GetPreferredSize());
+    gfx::Size size(GetWidget()->GetRootView()->GetPreferredSize());
     requisition->width = size.width();
     requisition->height = size.height();
   }
 }
 
 void WidgetGtk::OnSizeAllocate(GtkWidget* widget, GtkAllocation* allocation) {
   // See comment next to size_ as to why we do this. Also note, it's tempting
   // to put this in the static method so subclasses don't need to worry about
   // it, but if a subclasses needs to set a shape then they need to always
   // reset the shape in this method regardless of whether the size changed.
@@ skipping 114 matching lines @@
     drop_target_.reset(NULL);
   }
 }
 
 gboolean WidgetGtk::OnDragMotion(GtkWidget* widget,
                                  GdkDragContext* context,
                                  gint x,
                                  gint y,
                                  guint time) {
   if (!drop_target_.get())
-    drop_target_.reset(new DropTargetGtk(GetRootView(), context));
+    drop_target_.reset(new DropTargetGtk(GetWidget()->GetRootView(), context));
   return drop_target_->OnDragMotion(context, x, y, time);
 }
 
 gboolean WidgetGtk::OnEnterNotify(GtkWidget* widget, GdkEventCrossing* event) {
   if (HasMouseCapture() && event->mode == GDK_CROSSING_GRAB) {
     // Doing a grab results an async enter event, regardless of where the mouse
     // is. We don't want to generate a mouse move in this case.
     return false;
   }
 
-  if (!last_mouse_event_was_move_ && !is_mouse_button_pressed_) {
+  if (!GetWidget()->last_mouse_event_was_move_ &&
+      !GetWidget()->is_mouse_button_pressed_) {
     // When a mouse button is pressed gtk generates a leave, enter, press.
     // RootView expects to get a mouse move before a press, otherwise enter is
     // not set. So we generate a move here.
     GdkEventMotion motion = { GDK_MOTION_NOTIFY, event->window,
         event->send_event, event->time, event->x, event->y, NULL, event->state,
         0, NULL, event->x_root, event->y_root };
 
     // If this event is the result of pressing a button then one of the button
     // modifiers is set. Unset it as we're compensating for the leave generated
     // when you press a button.
     motion.state &= ~(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK);
 
     MouseEvent mouse_event(TransformEvent(&motion));
     delegate_->OnMouseEvent(mouse_event);
   }
-
   return false;
 }
 
 gboolean WidgetGtk::OnLeaveNotify(GtkWidget* widget, GdkEventCrossing* event) {
-  last_mouse_event_was_move_ = false;
-  if (!HasMouseCapture() && !is_mouse_button_pressed_) {
+  GetWidget()->ResetLastMouseMoveFlag();
+
+  if (!HasMouseCapture() && !GetWidget()->is_mouse_button_pressed_) {
     MouseEvent mouse_event(TransformEvent(event));
     delegate_->OnMouseEvent(mouse_event);
   }
   return false;
 }
 
 gboolean WidgetGtk::OnMotionNotify(GtkWidget* widget, GdkEventMotion* event) {
   MouseEvent mouse_event(TransformEvent(event));
   delegate_->OnMouseEvent(mouse_event);
   return true;
@@ skipping 139 matching lines @@
 void WidgetGtk::HandleXGrabBroke() {
 }
 
 void WidgetGtk::HandleGtkGrabBroke() {
   delegate_->OnMouseCaptureLost();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, private:
 
-RootView* WidgetGtk::CreateRootView() {
-  return new RootView(this);
-}
-
 gfx::AcceleratedWidget WidgetGtk::GetAcceleratedWidget() {
   DCHECK(window_contents_ && window_contents_->window);
   return GDK_WINDOW_XID(window_contents_->window);
 }
 
 void WidgetGtk::DispatchKeyEventPostIME(const KeyEvent& key) {
   // Always reset |should_handle_menu_key_release_| unless we are handling a
   // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
   // be activated when handling a VKEY_MENU key release event which is preceded
   // by an unhandled VKEY_MENU key press event. See also HandleKeyboardEvent().
@@ skipping 22 matching lines @@
   // always consumes the key event and send it back to us later by calling
   // HandleKeyboardEvent() directly, if it's not handled by webkit.
   if (!handled)
     handled = HandleKeyboardEvent(key);
 
   // Dispatch the key event for bindings processing.
   if (!handled && event && GTK_IS_WINDOW(widget_))
     gtk_bindings_activate_event(GTK_OBJECT(widget_), event);
 }
 
-void WidgetGtk::SetInitParams(const InitParams& params) {
+void WidgetGtk::SetInitParams(const Widget::InitParams& params) {
   DCHECK(!GetNativeView());
 
   delete_on_destroy_ = params.delete_on_destroy;
   child_ = params.child;
 
+  // TODO(beng): The secondary checks here actually obviate the need for
+  //             params.transient but that's only because WidgetGtk considers
+  //             any top-level widget to be a transient widget. We will probably
+  //             want to ammend this assumption at some point.
+  if (params.transient || params.parent || params.parent_widget)
+    transient_to_parent_  = true;
   if (params.transparent)
     MakeTransparent();
   if (!params.accept_events && !child_)
     ignore_events_ = true;
   if (params.double_buffer)
     EnableDoubleBuffer(true);
-
-  if (params.type == InitParams::TYPE_MENU) {
-    GdkEvent* event = gtk_get_current_event();
-    if (event) {
-      is_mouse_button_pressed_ = event->type == GDK_BUTTON_PRESS ||
-          event->type == GDK_2BUTTON_PRESS ||
-          event->type == GDK_3BUTTON_PRESS;
-      gdk_event_free(event);
-    }
-  }
 }
 
 gboolean WidgetGtk::OnWindowPaint(GtkWidget* widget, GdkEventExpose* event) {
   // Clear the background to be totally transparent. We don't need to
   // paint the root view here as that is done by OnPaint.
   DCHECK(transparent_);
   DrawTransparentBackground(widget, event);
   // The Keyboard layout view has a renderer that covers the entire
   // window, which prevents OnPaint from being called on window_contents_,
   // so we need to remove the FREEZE_UPDATES property here.
@@ skipping 26 matching lines @@
   return false;
 }
 
 // static
 Window* WidgetGtk::GetWindowImpl(GtkWidget* widget) {
   GtkWidget* parent = widget;
   while (parent) {
     WidgetGtk* widget_gtk = static_cast<WidgetGtk*>(
         NativeWidget::GetNativeWidgetForNativeView(parent));
     if (widget_gtk && widget_gtk->is_window_)
-      return static_cast<WindowGtk*>(widget_gtk);
+      return static_cast<WindowGtk*>(widget_gtk)->GetWindow();
     parent = gtk_widget_get_parent(parent);
   }
   return NULL;
 }
 
-void WidgetGtk::CreateGtkWidget(const InitParams& params) {
+void WidgetGtk::CreateGtkWidget(const Widget::InitParams& params) {
   // We turn off double buffering for two reasons:
   // 1. We draw to a canvas then composite to the screen, which means we're
   //    doing our own double buffering already.
   // 2. GTKs double buffering clips to the dirty region. RootView occasionally
   //    needs to expand the paint region (see RootView::OnPaint). This means
   //    that if we use GTK's double buffering and we tried to expand the dirty
   //    region, it wouldn't get painted.
   if (child_) {
     window_contents_ = widget_ = gtk_views_fixed_new();
     gtk_widget_set_name(widget_, "views-gtkwidget-child-fixed");
@@ skipping 33 matching lines @@
       // This can't be done without a parent present, or stale data
       // might show up on the screen as seen in
       // http://code.google.com/p/chromium/issues/detail?id=53870
       GtkAllocation alloc =
           { 0, 0, params.bounds.width(), params.bounds.height() };
       gtk_widget_size_allocate(widget_, &alloc);
     }
   } else {
     // Use our own window class to override GtkWindow's move_focus method.
     widget_ = gtk_views_window_new(
-        params.type == InitParams::TYPE_WINDOW ? GTK_WINDOW_TOPLEVEL
-                                               : GTK_WINDOW_POPUP);
+        params.type == Widget::InitParams::TYPE_WINDOW ? GTK_WINDOW_TOPLEVEL
+                                                       : GTK_WINDOW_POPUP);
     gtk_widget_set_name(widget_, "views-gtkwidget-window");
     if (transient_to_parent_) {
       gtk_window_set_transient_for(GTK_WINDOW(widget_),
                                    GTK_WINDOW(params.parent));
     }
     GTK_WIDGET_UNSET_FLAGS(widget_, GTK_DOUBLE_BUFFERED);
 
     // Gtk determines the size for windows based on the requested size of the
     // child. For WidgetGtk the child is a fixed. If the fixed ends up with a
     // child widget it's possible the child widget will drive the requested size
@@ skipping 18 matching lines @@
     gtk_window_set_position(GTK_WINDOW(widget_), GTK_WIN_POS_NONE);
 
     window_contents_ = gtk_views_fixed_new();
     gtk_widget_set_name(window_contents_, "views-gtkwidget-window-fixed");
     if (!is_double_buffered_)
       GTK_WIDGET_UNSET_FLAGS(window_contents_, GTK_DOUBLE_BUFFERED);
     gtk_fixed_set_has_window(GTK_FIXED(window_contents_), true);
     gtk_container_add(GTK_CONTAINER(widget_), window_contents_);
     gtk_widget_show(window_contents_);
     g_object_set_data(G_OBJECT(window_contents_), kNativeWidgetKey,
-                       static_cast<Widget*>(this));
+                       static_cast<WidgetGtk*>(this));
     if (transparent_)
       ConfigureWidgetForTransparentBackground(NULL);
 
     if (ignore_events_)
       ConfigureWidgetForIgnoreEvents();
 
     // Realize the window_contents_ so that we can always get a handle for
     // acceleration. Without this we need to check every time paint is
     // invoked.
     gtk_widget_realize(window_contents_);
@@ skipping 62 matching lines @@
   cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
   gdk_cairo_region(cr, event->region);
   cairo_fill(cr);
   cairo_destroy(cr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, public:
 
 // static
-Widget* Widget::CreateWidget() {
-  return new WidgetGtk();
-}
-
-// static
 void Widget::NotifyLocaleChanged() {
   GList *window_list = gtk_window_list_toplevels();
   for (GList* element = window_list; element; element = g_list_next(element)) {
     NativeWidget* native_widget =
         NativeWidget::GetNativeWidgetForNativeWindow(GTK_WINDOW(element->data));
     if (native_widget)
       native_widget->GetWidget()->LocaleChanged();
   }
   g_list_free(window_list);
 }
 
 // static
+void Widget::CloseAllSecondaryWidgets() {
+  GList* windows = gtk_window_list_toplevels();
+  for (GList* window = windows; window;
+       window = g_list_next(window)) {
+    NativeWidget* native_widget = NativeWidget::GetNativeWidgetForNativeView(
+        GTK_WIDGET(window->data));
+    if (native_widget) {
+      Widget* widget = native_widget->GetWidget();
+      if (widget->is_secondary_widget())
+        widget->Close();
+    }
+  }
+  g_list_free(windows);
+}
+
+// static
 bool Widget::ConvertRect(const Widget* source,
                          const Widget* target,
                          gfx::Rect* rect) {
   DCHECK(source);
   DCHECK(target);
   DCHECK(rect);
 
   GtkWidget* source_widget = source->GetNativeView();
   GtkWidget* target_widget = target->GetNativeView();
   if (source_widget == target_widget)
     return true;
 
   if (!source_widget || !target_widget)
     return false;
 
   GdkRectangle gdk_rect = rect->ToGdkRectangle();
   if (gtk_widget_translate_coordinates(source_widget, target_widget,
                                        gdk_rect.x, gdk_rect.y,
                                        &gdk_rect.x, &gdk_rect.y)) {
     *rect = gdk_rect;
     return true;
   }
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidget, public:
 
 // static
+NativeWidget* NativeWidget::CreateNativeWidget(
+    internal::NativeWidgetDelegate* delegate) {
+  return new WidgetGtk(delegate);
+}
+
+// static
 NativeWidget* NativeWidget::GetNativeWidgetForNativeView(
     gfx::NativeView native_view) {
   if (!native_view)
     return NULL;
   return reinterpret_cast<WidgetGtk*>(
       g_object_get_data(G_OBJECT(native_view), kNativeWidgetKey));
 }
 
 // static
 NativeWidget* NativeWidget::GetNativeWidgetForNativeWindow(
@@ skipping 31 matching lines @@
     return;
 
   NativeWidget* native_widget = GetNativeWidgetForNativeView(native_view);
   if (native_widget)
     children->insert(native_widget);
   gtk_container_foreach(GTK_CONTAINER(native_view),
                         EnumerateChildWidgetsForNativeWidgets,
                         reinterpret_cast<gpointer>(children));
 }
 
+// static
+void NativeWidget::ReparentNativeView(gfx::NativeView native_view,
+                                      gfx::NativeView new_parent) {
+  if (!native_view)
+    return;
+
+  gfx::NativeView previous_parent = gtk_widget_get_parent(native_view);
+  if (previous_parent == new_parent)
+    return;
+
+  NativeWidgets widgets;
+  GetAllNativeWidgets(native_view, &widgets);
+
+  // First notify all the widgets that they are being disassociated
+  // from their previous parent.
+  for (NativeWidgets::iterator it = widgets.begin();
+       it != widgets.end(); ++it) {
+    // TODO(beng): Rename this notification to NotifyNativeViewChanging()
+    // and eliminate the bool parameter.
+    (*it)->GetWidget()->NotifyNativeViewHierarchyChanged(false,
+                                                         previous_parent);
+  }
+
+  if (gtk_widget_get_parent(native_view))
+    gtk_widget_reparent(native_view, new_parent);
+  else
+    gtk_container_add(GTK_CONTAINER(new_parent), native_view);
+
+  // And now, notify them that they have a brand new parent.
+  for (NativeWidgets::iterator it = widgets.begin();
+       it != widgets.end(); ++it) {
+    (*it)->GetWidget()->NotifyNativeViewHierarchyChanged(true,
+                                                         new_parent);
+  }
+}
+
 }  // namespace views