Rework the way Widget::Init works:

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 265 matching lines @@
   return drag_widget;
 }
 
 // static
 GtkWidget* WidgetGtk::null_parent_ = NULL;
 bool WidgetGtk::debug_paint_enabled_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, public:
 
-WidgetGtk::WidgetGtk(Type type)
+WidgetGtk::WidgetGtk()
     : is_window_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(delegate_(this)),
-      type_(type),
       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),
@@ skipping 17 matching lines @@
       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 (type_ != TYPE_CHILD)
-    ActiveWindowWatcherX::RemoveObserver(this);
 }
 
 GtkWindow* WidgetGtk::GetTransientParent() const {
-  return (type_ != TYPE_CHILD && widget_) ?
+  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_);
 
   if (!gdk_screen_is_composited(gdk_screen_get_default())) {
     // Transparency is only supported for compositing window managers.
     // NOTE: there's a race during ChromeOS startup such that X might think
@@ skipping 14 matching lines @@
 void WidgetGtk::EnableDoubleBuffer(bool enabled) {
   is_double_buffered_ = enabled;
   if (window_contents_) {
     if (is_double_buffered_)
       GTK_WIDGET_SET_FLAGS(window_contents_, GTK_DOUBLE_BUFFERED);
     else
       GTK_WIDGET_UNSET_FLAGS(window_contents_, GTK_DOUBLE_BUFFERED);
   }
 }
 
-bool WidgetGtk::MakeIgnoreEvents() {
-  // Transparency can only be enabled for windows/popups and only if we haven't
-  // realized the widget.
-  DCHECK(!widget_ && type_ != TYPE_CHILD);
-
-  ignore_events_ = true;
-  return true;
-}
-
 void WidgetGtk::AddChild(GtkWidget* child) {
   gtk_container_add(GTK_CONTAINER(window_contents_), child);
 }
 
 void WidgetGtk::RemoveChild(GtkWidget* child) {
   // We can be called after the contents widget has been destroyed, e.g. any
   // NativeViewHost not removed from the view hierarchy before the window is
   // closed.
   if (GTK_IS_CONTAINER(window_contents_)) {
     gtk_container_remove(GTK_CONTAINER(window_contents_), child);
@@ skipping 95 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, ActiveWindowWatcherX::Observer implementation:
 
 void WidgetGtk::ActiveWindowChanged(GdkWindow* active_window) {
   if (!GetNativeView())
     return;
 
   bool was_active = IsActive();
   is_active_ = (active_window == GTK_WIDGET(GetNativeView())->window);
-  if (!is_active_ && active_window && type_ != TYPE_CHILD) {
+  if (!is_active_ && active_window && !child_) {
     // We're not active, but the force the window to be rendered as active if
     // a child window is transient to us.
     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();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, Widget implementation:
 
-void WidgetGtk::InitWithWidget(Widget* parent,
-                               const gfx::Rect& bounds) {
-  WidgetGtk* parent_gtk = static_cast<WidgetGtk*>(parent);
-  GtkWidget* native_parent = NULL;
-  if (parent != NULL) {
-    if (type_ != TYPE_CHILD) {
-      // window's parent has to be window.
-      native_parent = parent_gtk->GetNativeView();
-    } else {
-      native_parent = parent_gtk->window_contents();
-    }
-  }
-  Init(native_parent, bounds);
-}
-
-void WidgetGtk::Init(GtkWidget* parent,
-                     const gfx::Rect& bounds) {
-  Widget::Init(parent, bounds);
-  if (type_ != TYPE_CHILD)
-    ActiveWindowWatcherX::AddObserver(this);
-
-  // Make container here.
-  CreateGtkWidget(parent, bounds);
-  delegate_->OnNativeWidgetCreated();
-
-  // Creates input method for toplevel widget after calling
-  // delegate_->OnNativeWidgetCreated(), to make sure that focus manager is
-  // already created at this point.
-  // TODO(suzhe): Always enable input method when we start to use
-  // RenderWidgetHostViewViews in normal ChromeOS.
-#if defined(TOUCH_UI) && defined(HAVE_IBUS)
-  if (type_ != TYPE_CHILD) {
-    input_method_.reset(new InputMethodIBus(this));
-#else
-  if (type_ != TYPE_CHILD && NativeTextfieldViews::IsTextfieldViewsEnabled()) {
-    input_method_.reset(new InputMethodGtk(this));
-#endif
-    input_method_->Init(GetWidget());
-  }
-
-  if (opacity_ != 255)
-    SetOpacity(opacity_);
-
-  // Make sure we receive our motion events.
-
-  // In general we register most events on the parent of all widgets. At a
-  // minimum we need painting to happen on the parent (otherwise painting
-  // doesn't work at all), and similarly we need mouse release events on the
-  // parent as windows don't get mouse releases.
-  gtk_widget_add_events(window_contents_,
-                        GDK_ENTER_NOTIFY_MASK |
-                        GDK_LEAVE_NOTIFY_MASK |
-                        GDK_BUTTON_PRESS_MASK |
-                        GDK_BUTTON_RELEASE_MASK |
-                        GDK_POINTER_MOTION_MASK |
-                        GDK_KEY_PRESS_MASK |
-                        GDK_KEY_RELEASE_MASK);
-
-  g_signal_connect_after(G_OBJECT(window_contents_), "size_request",
-                         G_CALLBACK(&OnSizeRequestThunk), this);
-  g_signal_connect_after(G_OBJECT(window_contents_), "size_allocate",
-                         G_CALLBACK(&OnSizeAllocateThunk), this);
-  gtk_widget_set_app_paintable(window_contents_, true);
-  g_signal_connect(window_contents_, "expose_event",
-                   G_CALLBACK(&OnPaintThunk), this);
-  g_signal_connect(window_contents_, "enter_notify_event",
-                   G_CALLBACK(&OnEnterNotifyThunk), this);
-  g_signal_connect(window_contents_, "leave_notify_event",
-                   G_CALLBACK(&OnLeaveNotifyThunk), this);
-  g_signal_connect(window_contents_, "motion_notify_event",
-                   G_CALLBACK(&OnMotionNotifyThunk), this);
-  g_signal_connect(window_contents_, "button_press_event",
-                   G_CALLBACK(&OnButtonPressThunk), this);
-  g_signal_connect(window_contents_, "button_release_event",
-                   G_CALLBACK(&OnButtonReleaseThunk), this);
-  g_signal_connect(window_contents_, "grab_broken_event",
-                   G_CALLBACK(&OnGrabBrokeEventThunk), this);
-  g_signal_connect(window_contents_, "grab_notify",
-                   G_CALLBACK(&OnGrabNotifyThunk), this);
-  g_signal_connect(window_contents_, "scroll_event",
-                   G_CALLBACK(&OnScrollThunk), this);
-  g_signal_connect(window_contents_, "visibility_notify_event",
-                   G_CALLBACK(&OnVisibilityNotifyThunk), this);
-
-  // In order to receive notification when the window is no longer the front
-  // window, we need to install these on the widget.
-  // NOTE: this doesn't work with focus follows mouse.
-  g_signal_connect(widget_, "focus_in_event",
-                   G_CALLBACK(&OnFocusInThunk), this);
-  g_signal_connect(widget_, "focus_out_event",
-                   G_CALLBACK(&OnFocusOutThunk), this);
-  g_signal_connect(widget_, "destroy",
-                   G_CALLBACK(&OnDestroyThunk), this);
-  g_signal_connect(widget_, "show",
-                   G_CALLBACK(&OnShowThunk), this);
-  g_signal_connect(widget_, "map",
-                   G_CALLBACK(&OnMapThunk), this);
-  g_signal_connect(widget_, "hide",
-                   G_CALLBACK(&OnHideThunk), this);
-
-  // Views/FocusManager (re)sets the focus to the root window,
-  // so we need to connect signal handlers to the gtk window.
-  // See views::Views::Focus and views::FocusManager::ClearNativeFocus
-  // for more details.
-  g_signal_connect(widget_, "key_press_event",
-                   G_CALLBACK(&OnEventKeyThunk), this);
-  g_signal_connect(widget_, "key_release_event",
-                   G_CALLBACK(&OnEventKeyThunk), this);
-
-  // Drag and drop.
-  gtk_drag_dest_set(window_contents_, static_cast<GtkDestDefaults>(0),
-                    NULL, 0, GDK_ACTION_COPY);
-  g_signal_connect(window_contents_, "drag_motion",
-                   G_CALLBACK(&OnDragMotionThunk), this);
-  g_signal_connect(window_contents_, "drag_data_received",
-                   G_CALLBACK(&OnDragDataReceivedThunk), this);
-  g_signal_connect(window_contents_, "drag_drop",
-                   G_CALLBACK(&OnDragDropThunk), this);
-  g_signal_connect(window_contents_, "drag_leave",
-                   G_CALLBACK(&OnDragLeaveThunk), this);
-  g_signal_connect(window_contents_, "drag_data_get",
-                   G_CALLBACK(&OnDragDataGetThunk), this);
-  g_signal_connect(window_contents_, "drag_end",
-                   G_CALLBACK(&OnDragEndThunk), this);
-  g_signal_connect(window_contents_, "drag_failed",
-                   G_CALLBACK(&OnDragFailedThunk), this);
-
-  tooltip_manager_.reset(new TooltipManagerGtk(this));
-
-  // Register for tooltips.
-  g_object_set(G_OBJECT(window_contents_), "has-tooltip", TRUE, NULL);
-  g_signal_connect(window_contents_, "query_tooltip",
-                   G_CALLBACK(&OnQueryTooltipThunk), this);
-
-  if (type_ == TYPE_CHILD) {
-    if (parent) {
-      SetBounds(bounds);
-    }
-  } else {
-    if (bounds.width() > 0 && bounds.height() > 0)
-      gtk_window_resize(GTK_WINDOW(widget_), bounds.width(), bounds.height());
-    gtk_window_move(GTK_WINDOW(widget_), bounds.x(), bounds.y());
-  }
-}
-
 gfx::NativeView WidgetGtk::GetNativeView() const {
   return widget_;
 }
 
 bool WidgetGtk::GetAccelerator(int cmd_id, ui::Accelerator* accelerator) {
   NOTIMPLEMENTED();
   return false;
 }
 
 Window* WidgetGtk::GetWindow() {
@@ skipping 16 matching lines @@
     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(type_ != TYPE_CHILD);
+  DCHECK(!child_);
   if (!GetNativeView()) {
     NOTREACHED();
     return;
   }
   gtk_window_set_focus(GTK_WINDOW(GetNativeView()), NULL);
 }
 
 bool WidgetGtk::HandleKeyboardEvent(const KeyEvent& key) {
   if (!GetFocusManager())
     return false;
@@ skipping 62 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::SetCreateParams(const CreateParams& params) {
-  DCHECK(!GetNativeView());
+void WidgetGtk::InitNativeWidget(const CreateParams& params) {
+  SetCreateParams(params);
 
-  // Set non-style attributes.
-  set_delete_on_destroy(params.delete_on_destroy);
+  CreateParams 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 (params.transparent)
-    MakeTransparent();
-  if (!params.accept_events)
-    MakeIgnoreEvents();
+  if (!child_)
+    ActiveWindowWatcherX::AddObserver(this);
 
-  if (params.type == CreateParams::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);
-    }
+  // Make container here.
+  CreateGtkWidget(modified_params);
+  delegate_->OnNativeWidgetCreated();
+
+  // Creates input method for toplevel widget after calling
+  // delegate_->OnNativeWidgetCreated(), to make sure that focus manager is
+  // already created at this point.
+  // TODO(suzhe): Always enable input method when we start to use
+  // RenderWidgetHostViewViews in normal ChromeOS.
+#if defined(TOUCH_UI) && defined(HAVE_IBUS)
+  if (!child_) {
+    input_method_.reset(new InputMethodIBus(this));
+#else
+  if (!child_ && NativeTextfieldViews::IsTextfieldViewsEnabled()) {
+    input_method_.reset(new InputMethodGtk(this));
+#endif
+    input_method_->Init(GetWidget());
+  }
+
+  if (opacity_ != 255)
+    SetOpacity(opacity_);
+
+  // Make sure we receive our motion events.
+
+  // In general we register most events on the parent of all widgets. At a
+  // minimum we need painting to happen on the parent (otherwise painting
+  // doesn't work at all), and similarly we need mouse release events on the
+  // parent as windows don't get mouse releases.
+  gtk_widget_add_events(window_contents_,
+                        GDK_ENTER_NOTIFY_MASK |
+                        GDK_LEAVE_NOTIFY_MASK |
+                        GDK_BUTTON_PRESS_MASK |
+                        GDK_BUTTON_RELEASE_MASK |
+                        GDK_POINTER_MOTION_MASK |
+                        GDK_KEY_PRESS_MASK |
+                        GDK_KEY_RELEASE_MASK);
+
+  g_signal_connect_after(G_OBJECT(window_contents_), "size_request",
+                         G_CALLBACK(&OnSizeRequestThunk), this);
+  g_signal_connect_after(G_OBJECT(window_contents_), "size_allocate",
+                         G_CALLBACK(&OnSizeAllocateThunk), this);
+  gtk_widget_set_app_paintable(window_contents_, true);
+  g_signal_connect(window_contents_, "expose_event",
+                   G_CALLBACK(&OnPaintThunk), this);
+  g_signal_connect(window_contents_, "enter_notify_event",
+                   G_CALLBACK(&OnEnterNotifyThunk), this);
+  g_signal_connect(window_contents_, "leave_notify_event",
+                   G_CALLBACK(&OnLeaveNotifyThunk), this);
+  g_signal_connect(window_contents_, "motion_notify_event",
+                   G_CALLBACK(&OnMotionNotifyThunk), this);
+  g_signal_connect(window_contents_, "button_press_event",
+                   G_CALLBACK(&OnButtonPressThunk), this);
+  g_signal_connect(window_contents_, "button_release_event",
+                   G_CALLBACK(&OnButtonReleaseThunk), this);
+  g_signal_connect(window_contents_, "grab_broken_event",
+                   G_CALLBACK(&OnGrabBrokeEventThunk), this);
+  g_signal_connect(window_contents_, "grab_notify",
+                   G_CALLBACK(&OnGrabNotifyThunk), this);
+  g_signal_connect(window_contents_, "scroll_event",
+                   G_CALLBACK(&OnScrollThunk), this);
+  g_signal_connect(window_contents_, "visibility_notify_event",
+                   G_CALLBACK(&OnVisibilityNotifyThunk), this);
+
+  // In order to receive notification when the window is no longer the front
+  // window, we need to install these on the widget.
+  // NOTE: this doesn't work with focus follows mouse.
+  g_signal_connect(widget_, "focus_in_event",
+                   G_CALLBACK(&OnFocusInThunk), this);
+  g_signal_connect(widget_, "focus_out_event",
+                   G_CALLBACK(&OnFocusOutThunk), this);
+  g_signal_connect(widget_, "destroy",
+                   G_CALLBACK(&OnDestroyThunk), this);
+  g_signal_connect(widget_, "show",
+                   G_CALLBACK(&OnShowThunk), this);
+  g_signal_connect(widget_, "map",
+                   G_CALLBACK(&OnMapThunk), this);
+  g_signal_connect(widget_, "hide",
+                   G_CALLBACK(&OnHideThunk), this);
+
+  // Views/FocusManager (re)sets the focus to the root window,
+  // so we need to connect signal handlers to the gtk window.
+  // See views::Views::Focus and views::FocusManager::ClearNativeFocus
+  // for more details.
+  g_signal_connect(widget_, "key_press_event",
+                   G_CALLBACK(&OnEventKeyThunk), this);
+  g_signal_connect(widget_, "key_release_event",
+                   G_CALLBACK(&OnEventKeyThunk), this);
+
+  // Drag and drop.
+  gtk_drag_dest_set(window_contents_, static_cast<GtkDestDefaults>(0),
+                    NULL, 0, GDK_ACTION_COPY);
+  g_signal_connect(window_contents_, "drag_motion",
+                   G_CALLBACK(&OnDragMotionThunk), this);
+  g_signal_connect(window_contents_, "drag_data_received",
+                   G_CALLBACK(&OnDragDataReceivedThunk), this);
+  g_signal_connect(window_contents_, "drag_drop",
+                   G_CALLBACK(&OnDragDropThunk), this);
+  g_signal_connect(window_contents_, "drag_leave",
+                   G_CALLBACK(&OnDragLeaveThunk), this);
+  g_signal_connect(window_contents_, "drag_data_get",
+                   G_CALLBACK(&OnDragDataGetThunk), this);
+  g_signal_connect(window_contents_, "drag_end",
+                   G_CALLBACK(&OnDragEndThunk), this);
+  g_signal_connect(window_contents_, "drag_failed",
+                   G_CALLBACK(&OnDragFailedThunk), this);
+
+  tooltip_manager_.reset(new TooltipManagerGtk(this));
+
+  // Register for tooltips.
+  g_object_set(G_OBJECT(window_contents_), "has-tooltip", TRUE, NULL);
+  g_signal_connect(window_contents_, "query_tooltip",
+                   G_CALLBACK(&OnQueryTooltipThunk), this);
+
+  if (child_) {
+    if (parent)
+      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;
 }
 
 void WidgetGtk::SetNativeWindowProperty(const char* name, void* value) {
   g_object_set_data(G_OBJECT(widget_), name, value);
 }
@@ skipping 57 matching lines @@
     gtk_window_get_size(GTK_WINDOW(widget_), &w, &h);
   } else {
     GetWidgetPositionOnScreen(widget_, &x, &y);
     w = widget_->allocation.width;
     h = widget_->allocation.height;
   }
   return gfx::Rect(x, y, w, h);
 }
 
 void WidgetGtk::SetBounds(const gfx::Rect& bounds) {
-  if (type_ == TYPE_CHILD) {
+  if (child_) {
     GtkWidget* parent = gtk_widget_get_parent(widget_);
     if (GTK_IS_VIEWS_FIXED(parent)) {
       WidgetGtk* parent_widget = static_cast<WidgetGtk*>(
           NativeWidget::GetNativeWidgetForNativeView(parent));
       parent_widget->PositionChild(widget_, bounds.x(), bounds.y(),
                                    bounds.width(), bounds.height());
     } else {
       DCHECK(GTK_IS_FIXED(parent))
           << "Parent of WidgetGtk has to be Fixed or ViewsFixed";
       // Just request the size if the parent is not WidgetGtk but plain
@@ skipping 17 matching lines @@
     // TODO: this may need to set an initial size if not showing.
     // TODO: need to constrain based on screen size.
     if (!bounds.IsEmpty()) {
       gtk_window_resize(gtk_window, bounds.width(), bounds.height());
     }
     gtk_window_move(gtk_window, bounds.x(), bounds.y());
   }
 }
 
 void WidgetGtk::SetSize(const gfx::Size& size) {
-  if (type_ == TYPE_CHILD) {
+  if (child_) {
     GtkWidget* parent = gtk_widget_get_parent(widget_);
     if (GTK_IS_VIEWS_FIXED(parent)) {
       gtk_views_fixed_set_widget_size(widget_, size.width(), size.height());
     } else {
       DCHECK(GTK_IS_FIXED(parent))
           << "Parent of WidgetGtk has to be Fixed or ViewsFixed";
       gtk_widget_set_size_request(widget_, size.width(), size.height());
     }
   } else {
     if (GTK_WIDGET_MAPPED(widget_))
@@ skipping 55 matching lines @@
 void WidgetGtk::SetOpacity(unsigned char opacity) {
   opacity_ = opacity;
   if (widget_) {
     // We can only set the opacity when the widget has been realized.
     gdk_window_set_opacity(widget_->window, static_cast<gdouble>(opacity) /
       static_cast<gdouble>(255));
   }
 }
 
 void WidgetGtk::SetAlwaysOnTop(bool on_top) {
-  DCHECK(type_ != TYPE_CHILD);
+  DCHECK(!child_);
   always_on_top_ = on_top;
   if (widget_)
     gtk_window_set_keep_above(GTK_WINDOW(widget_), on_top);
 }
 
 bool WidgetGtk::IsVisible() const {
   return GTK_WIDGET_VISIBLE(widget_);
 }
 
 bool WidgetGtk::IsActive() const {
-  DCHECK(type_ != TYPE_CHILD);
+  DCHECK(!child_);
   return is_active_;
 }
 
 bool WidgetGtk::IsAccessibleWidget() const {
   return false;
 }
 
 bool WidgetGtk::ContainsNativeView(gfx::NativeView native_view) const {
   // TODO(port)  See implementation in WidgetWin::ContainsNativeView.
   NOTREACHED() << "WidgetGtk::ContainsNativeView is not implemented.";
@@ skipping 32 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 (type_ == TYPE_CHILD) {
+  if (child_) {
     gfx::Size size(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.
   gfx::Size new_size(allocation->width, allocation->height);
   if (new_size == size_)
     return;
   size_ = new_size;
   delegate_->OnSizeChanged(size_);
 }
 
 gboolean WidgetGtk::OnPaint(GtkWidget* widget, GdkEventExpose* event) {
-  if (transparent_ && type_ == TYPE_CHILD) {
+  if (transparent_ && child_) {
     // Clear the background before drawing any view and native components.
     DrawTransparentBackground(widget, event);
     if (!CompositePainter::IsComposited(widget_) &&
         gdk_screen_is_composited(gdk_screen_get_default())) {
       // Let the parent draw the content only after something is drawn on
       // the widget.
       CompositePainter::SetComposited(widget_);
     }
   }
 
@@ skipping 12 matching lines @@
   }
 
   gfx::CanvasSkiaPaint canvas(event);
   if (!canvas.is_empty()) {
     canvas.set_composite_alpha(is_transparent());
     delegate_->OnNativeWidgetPaint(&canvas);
   }
 
   if (!painted_) {
     painted_ = true;
-    if (type_ != TYPE_CHILD)
+    if (!child_)
       UpdateFreezeUpdatesProperty(GTK_WINDOW(widget_), false /* remove */);
   }
   return false;  // False indicates other widgets should get the event as well.
 }
 
 void WidgetGtk::OnDragDataGet(GtkWidget* widget,
                               GdkDragContext* context,
                               GtkSelectionData* data,
                               guint info,
                               guint time) {
@@ skipping 140 matching lines @@
   return delegate_->OnMouseEvent(mouse_event);
 }
 
 gboolean WidgetGtk::OnFocusIn(GtkWidget* widget, GdkEventFocus* event) {
   if (has_focus_)
     return false;  // This is the second focus-in event in a row, ignore it.
   has_focus_ = true;
 
   should_handle_menu_key_release_ = false;
 
-  if (type_ == TYPE_CHILD)
+  if (child_)
     return false;
 
   // Only top-level Widget should have an InputMethod instance.
   if (input_method_.get())
     input_method_->OnFocus();
 
   // See description of got_initial_focus_in_ for details on this.
   if (!got_initial_focus_in_) {
     got_initial_focus_in_ = true;
     SetInitialFocus();
   }
   return false;
 }
 
 gboolean WidgetGtk::OnFocusOut(GtkWidget* widget, GdkEventFocus* event) {
   if (!has_focus_)
     return false;  // This is the second focus-out event in a row, ignore it.
   has_focus_ = false;
 
-  if (type_ == TYPE_CHILD)
+  if (child_)
     return false;
 
   // Only top-level Widget should have an InputMethod instance.
   if (input_method_.get())
     input_method_->OnBlur();
   return false;
 }
 
 gboolean WidgetGtk::OnEventKey(GtkWidget* widget, GdkEventKey* event) {
   KeyEvent key(reinterpret_cast<NativeEvent>(event));
@@ skipping 25 matching lines @@
 }
 
 void WidgetGtk::OnGrabNotify(GtkWidget* widget, gboolean was_grabbed) {
   if (!window_contents_)
     return;  // Grab broke after window destroyed, don't try processing it.
   gtk_grab_remove(window_contents_);
   HandleGtkGrabBroke();
 }
 
 void WidgetGtk::OnDestroy(GtkWidget* object) {
+  if (!child_)
+    ActiveWindowWatcherX::RemoveObserver(this);
   // Note that this handler is hooked to GtkObject::destroy.
   // NULL out pointers here since we might still be in an observerer list
   // until delstion happens.
   widget_ = window_contents_ = NULL;
   if (delete_on_destroy_) {
     // Delays the deletion of this WidgetGtk as we want its children to have
     // access to it when destroyed.
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 }
@@ skipping 66 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::SetCreateParams(const CreateParams& params) {
+  DCHECK(!GetNativeView());
+
+  delete_on_destroy_ = params.delete_on_destroy;
+  child_ = params.child;
+
+  if (params.transparent)
+    MakeTransparent();
+  if (!params.accept_events && !child_)
+    ignore_events_ = true;
+
+  if (params.type == CreateParams::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.
   if (!painted_) {
     painted_ = true;
     UpdateFreezeUpdatesProperty(GTK_WINDOW(widget_), false /* remove */);
   }
   return false;
 }
 
 void WidgetGtk::OnChildExpose(GtkWidget* child) {
-  DCHECK(type_ != TYPE_CHILD);
+  DCHECK(!child_);
   if (!painted_) {
     painted_ = true;
     UpdateFreezeUpdatesProperty(GTK_WINDOW(widget_), false /* remove */);
   }
   RemoveExposeHandlerIfExists(child);
 }
 
 // static
 gboolean WidgetGtk::ChildExposeHandler(GtkWidget* widget,
                                        GdkEventExpose* event) {
@@ skipping 13 matching lines @@
   while (parent) {
     WidgetGtk* widget_gtk = static_cast<WidgetGtk*>(
         NativeWidget::GetNativeWidgetForNativeView(parent));
     if (widget_gtk && widget_gtk->is_window_)
       return static_cast<WindowGtk*>(widget_gtk);
     parent = gtk_widget_get_parent(parent);
   }
   return NULL;
 }
 
-void WidgetGtk::CreateGtkWidget(GtkWidget* parent, const gfx::Rect& bounds) {
+void WidgetGtk::CreateGtkWidget(const CreateParams& 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 (type_ == TYPE_CHILD) {
+  if (child_) {
     window_contents_ = widget_ = gtk_views_fixed_new();
     gtk_widget_set_name(widget_, "views-gtkwidget-child-fixed");
     if (!is_double_buffered_)
       GTK_WIDGET_UNSET_FLAGS(widget_, GTK_DOUBLE_BUFFERED);
     gtk_fixed_set_has_window(GTK_FIXED(widget_), true);
-    if (!parent && !null_parent_) {
+    if (!params.parent && !null_parent_) {
       GtkWidget* popup = gtk_window_new(GTK_WINDOW_POPUP);
       null_parent_ = gtk_fixed_new();
       gtk_widget_set_name(widget_, "views-gtkwidget-null-parent");
       gtk_container_add(GTK_CONTAINER(popup), null_parent_);
       gtk_widget_realize(null_parent_);
     }
     if (transparent_) {
       // transparency has to be configured before widget is realized.
-      DCHECK(parent) << "Transparent widget must have parent when initialized";
-      ConfigureWidgetForTransparentBackground(parent);
+      DCHECK(params.parent) <<
+          "Transparent widget must have parent when initialized";
+      ConfigureWidgetForTransparentBackground(params.parent);
     }
-    gtk_container_add(GTK_CONTAINER(parent ? parent : null_parent_), widget_);
+    gtk_container_add(
+        GTK_CONTAINER(params.parent ? params.parent : null_parent_), widget_);
     gtk_widget_realize(widget_);
     if (transparent_) {
       // The widget has to be realized to set composited flag.
       // I tried "realize" signal to set this flag, but it did not work
       // when the top level is popup.
       DCHECK(GTK_WIDGET_REALIZED(widget_));
       gdk_window_set_composited(widget_->window, true);
     }
-    if (parent && !bounds.size().IsEmpty()) {
+    if (params.parent && !params.bounds.size().IsEmpty()) {
       // Make sure that an widget is given it's initial size before
       // we're done initializing, to take care of some potential
       // corner cases when programmatically arranging hierarchies as
       // seen in
       // http://code.google.com/p/chromium-os/issues/detail?id=5987
 
       // 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, bounds.width(), bounds.height() };
+      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(
-        (type_ == TYPE_WINDOW || type_ == TYPE_DECORATED_WINDOW) ?
-        GTK_WINDOW_TOPLEVEL : GTK_WINDOW_POPUP);
+        params.type == CreateParams::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(parent));
+    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
     // of the widget, which we don't want. We explicitly set a value of 1x1 here
     // so that gtk doesn't attempt to resize the window if we end up with a
     // situation where the requested size of a child of the fixed is greater
     // than the size of the window. By setting the size in this manner we're
     // also allowing users of WidgetGtk to change the requested size at any
     // time.
     gtk_widget_set_size_request(widget_, 1, 1);
 
-    if (!bounds.size().IsEmpty()) {
+    if (!params.bounds.size().IsEmpty()) {
       // When we realize the window, the window manager is given a size. If we
       // don't specify a size before then GTK defaults to 200x200. Specify
       // a size now so that the window manager sees the requested size.
-      GtkAllocation alloc = { 0, 0, bounds.width(), bounds.height() };
+      GtkAllocation alloc =
+          { 0, 0, params.bounds.width(), params.bounds.height() };
       gtk_widget_size_allocate(widget_, &alloc);
     }
-    if (type_ != TYPE_DECORATED_WINDOW) {
-      gtk_window_set_decorated(GTK_WINDOW(widget_), false);
-      // We'll take care of positioning our window.
-      gtk_window_set_position(GTK_WINDOW(widget_), GTK_WIN_POS_NONE);
-    }
+    gtk_window_set_decorated(GTK_WINDOW(widget_), false);
+    // We'll take care of positioning our window.
+    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));
@@ skipping 17 matching lines @@
   GdkColormap* rgba_colormap =
       gdk_screen_get_rgba_colormap(gtk_widget_get_screen(widget_));
   if (!rgba_colormap) {
     transparent_ = false;
     return;
   }
   // To make the background transparent we need to install the RGBA colormap
   // on both the window and fixed. In addition we need to make sure no
   // decorations are drawn. The last bit is to make sure the widget doesn't
   // attempt to draw a pixmap in it's background.
-  if (type_ != TYPE_CHILD) {
+  if (!child_) {
     DCHECK(parent == NULL);
     gtk_widget_set_colormap(widget_, rgba_colormap);
     gtk_widget_set_app_paintable(widget_, true);
     g_signal_connect(widget_, "expose_event",
                      G_CALLBACK(&OnWindowPaintThunk), this);
     gtk_widget_realize(widget_);
     gdk_window_set_decorations(widget_->window,
                                static_cast<GdkWMDecoration>(0));
   } else {
     DCHECK(parent);
@@ skipping 29 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(const CreateParams& params) {
-  // TODO(beng): coalesce with CreateParams::Type.
-  WidgetGtk::Type widget_gtk_type = WidgetGtk::TYPE_DECORATED_WINDOW;
-  switch (params.type) {
-    case CreateParams::TYPE_CONTROL:
-      widget_gtk_type = WidgetGtk::TYPE_CHILD;
-      break;
-    case CreateParams::TYPE_MENU:
-      widget_gtk_type = WidgetGtk::TYPE_POPUP;
-      break;
-    case CreateParams::TYPE_POPUP:
-      widget_gtk_type = WidgetGtk::TYPE_POPUP;
-      break;
-    case CreateParams::TYPE_WINDOW:
-      widget_gtk_type = WidgetGtk::TYPE_DECORATED_WINDOW;
-      break;
-    default:
-      NOTREACHED();
-      break;
-  }
-
-  WidgetGtk* widget = new WidgetGtk(widget_gtk_type);
-  widget->SetCreateParams(params);
-  return widget;
+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();
@@ skipping 76 matching lines @@
 
   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));
 }
 
 }  // namespace views