Rework the way Widget::Init works:

views/widget/widget_gtk.h

 // 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.
 
 #ifndef VIEWS_WIDGET_WIDGET_GTK_H_
 #define VIEWS_WIDGET_WIDGET_GTK_H_
 #pragma once
 
 #include <gtk/gtk.h>
 
@@ skipping 28 matching lines @@
 namespace internal {
 class NativeWidgetDelegate;
 }
 
 // Widget implementation for GTK.
 class WidgetGtk : public Widget,
                   public NativeWidget,
                   public ui::ActiveWindowWatcherX::Observer,
                   public internal::InputMethodDelegate {
  public:
-  // Type of widget.
-  enum Type {
-    // Used for popup type windows (bubbles, menus ...).
-    // NOTE: on X windows of this type can NOT get focus. If you need a popup
-    // like widget that can be focused use TYPE_WINDOW and set the window type
-    // to WINDOW_TYPE_CHROME_INFO_BUBBLE.
-    TYPE_POPUP,
-
-    // A top level window with no title or control buttons.
-    // NOTE: On ChromeOS TYPE_WINDOW and TYPE_DECORATED_WINDOW behave the same.
-    TYPE_WINDOW,
-
-    // A top level, decorated window.
-    // NOTE: On ChromeOS TYPE_WINDOW and TYPE_DECORATED_WINDOW behave the same.
-    TYPE_DECORATED_WINDOW,
-
-    // A child widget.
-    TYPE_CHILD
-  };
-
-  explicit WidgetGtk(Type type);
+  WidgetGtk();
   virtual ~WidgetGtk();
 
   // Marks this window as transient to its parent. A window that is transient
   // to its parent results in the parent rendering active when the child is
   // active.
   // This must be invoked before Init. This is only used for types other than
   // TYPE_CHILD. The default is false.
   // See gtk_window_set_transient_for for details.
   void make_transient_to_parent() {
     DCHECK(!widget_);
@@ skipping 11 matching lines @@
   // This works for both child and window types.
   bool MakeTransparent();
   bool is_transparent() const { return transparent_; }
 
   // Enable/Disable double buffering.This is neccessary to prevent
   // flickering in ScrollView, which has both native and view
   // controls.
   void EnableDoubleBuffer(bool enabled);
   bool is_double_buffered() const { return is_double_buffered_; }
 
-  // Makes the window pass all events through to any windows behind it.
-  // This must be invoked before Init. This does a couple of checks and returns
-  // true if the window can be made to ignore events. The actual work of making
-  // the window ignore events is done by ConfigureWidgetForIgnoreEvents.
-  bool MakeIgnoreEvents();
   bool is_ignore_events() const { return ignore_events_; }
 
-  // Sets whether or not we are deleted when the widget is destroyed. The
-  // default is true.
-  void set_delete_on_destroy(bool delete_on_destroy) {
-    delete_on_destroy_ = delete_on_destroy;
-  }
-
   // Adds and removes the specified widget as a child of this widget's contents.
   // These methods make sure to add the widget to the window's contents
   // container if this widget is a window.
   void AddChild(GtkWidget* child);
   void RemoveChild(GtkWidget* child);
 
   // A safe way to reparent a child widget to this widget. Calls
   // gtk_widget_reparent which handles refcounting to avoid destroying the
   // widget when removing it from its old parent.
   void ReparentChild(GtkWidget* child);
@@ skipping 24 matching lines @@
 
   // Gets the requested size of the widget.  This can be the size
   // stored in properties for a GtkViewsFixed, or in the requisitioned
   // size of other kinds of widgets.
   void GetRequestedSize(gfx::Size* out) const;
 
   // Overridden from ui::ActiveWindowWatcherX::Observer.
   virtual void ActiveWindowChanged(GdkWindow* active_window);
 
   // Overridden from Widget:
-  virtual void Init(gfx::NativeView parent, const gfx::Rect& bounds);
-  virtual void InitWithWidget(Widget* parent, const gfx::Rect& bounds);
   virtual gfx::NativeView GetNativeView() const;
   virtual bool GetAccelerator(int cmd_id, ui::Accelerator* accelerator);
   virtual Window* GetWindow();
   virtual const Window* GetWindow() const;
   virtual void ViewHierarchyChanged(bool is_add, View *parent,
                                     View *child);
   virtual void NotifyAccessibilityEvent(
       View* view,
       ui::AccessibilityTypes::Event event_type,
       bool send_native_event);
@@ skipping 24 matching lines @@
   // fill the entire area of the WidgetGtk to the view hierachy, you
   // need use this function to tell WM that when the widget is ready
   // to be shown.
   // Caller of this method do not need to disconnect this because the
   // handler will be removed upon the first invocation of the handler,
   // or when the widget is re-attached, and expose won't be emitted on
   // detached widget.
   static void RegisterChildExposeHandler(GtkWidget* widget);
 
   // Overridden from NativeWidget:
-  virtual void SetCreateParams(const CreateParams& params) OVERRIDE;
+  virtual void InitNativeWidget(const CreateParams& params) OVERRIDE;
   virtual Widget* GetWidget() OVERRIDE;
   virtual void SetNativeWindowProperty(const char* name, void* value) OVERRIDE;
   virtual void* GetNativeWindowProperty(const char* name) OVERRIDE;
   virtual TooltipManager* GetTooltipManager() const OVERRIDE;
   virtual bool IsScreenReaderActive() const OVERRIDE;
   virtual void SetMouseCapture() OVERRIDE;
   virtual void ReleaseMouseCapture() OVERRIDE;
   virtual bool HasMouseCapture() const OVERRIDE;
   virtual InputMethod* GetInputMethodNative() OVERRIDE;
   virtual void ReplaceInputMethod(InputMethod* input_method) OVERRIDE;
@@ skipping 87 matching lines @@
 
   // Overridden from Widget
   virtual RootView* CreateRootView() OVERRIDE;
 
   // Overridden from NativeWidget
   virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE;
 
   // Overridden from internal::InputMethodDelegate
   virtual void DispatchKeyEventPostIME(const KeyEvent& key) OVERRIDE;
 
+  void SetCreateParams(const CreateParams& params);
+
   // This is called only when the window is transparent.
   CHROMEGTK_CALLBACK_1(WidgetGtk, gboolean, OnWindowPaint, GdkEventExpose*);
 
   // Callbacks for expose event on child widgets. See the description of
   // RegisterChildChildExposeHandler.
   void OnChildExpose(GtkWidget* child);
   static gboolean ChildExposeHandler(GtkWidget* widget, GdkEventExpose* event);
 
   // Returns the first ancestor of |widget| that is a window.
   static Window* GetWindowImpl(GtkWidget* widget);
 
   // Creates the GtkWidget.
-  void CreateGtkWidget(GtkWidget* parent, const gfx::Rect& bounds);
+  void CreateGtkWidget(const CreateParams& params);
 
   // Invoked from create widget to enable the various bits needed for a
   // transparent background. This is only invoked if MakeTransparent has been
   // invoked.
   void ConfigureWidgetForTransparentBackground(GtkWidget* parent);
 
   // Invoked from create widget to enable the various bits needed for a
-  // window which doesn't receive events. This is only invoked if
-  // MakeIgnoreEvents has been invoked.
+  // window which doesn't receive events.
   void ConfigureWidgetForIgnoreEvents();
 
   // A utility function to draw a transparent background onto the |widget|.
   static void DrawTransparentBackground(GtkWidget* widget,
                                         GdkEventExpose* event);
 
   // A delegate implementation that handles events received here.
   internal::NativeWidgetDelegate* delegate_;
 
-  const Type type_;
-
   // Our native views. If we're a window/popup, then widget_ is the window and
   // window_contents_ is a GtkFixed. If we're not a window/popup, then widget_
   // and window_contents_ point to the same GtkFixed.
   GtkWidget* widget_;
   GtkWidget* window_contents_;
 
   // Child GtkWidgets created with no parent need to be parented to a valid top
   // level window otherwise Gtk throws a fit. |null_parent_| is an invisible
   // popup that such GtkWidgets are parented to.
   static GtkWidget* null_parent_;
 
+  // True if the widget is a child of some other widget.
+  bool child_;
+
   // The TooltipManager.
   // WARNING: RootView's destructor calls into the TooltipManager. As such, this
   // must be destroyed AFTER root_view_.
   scoped_ptr<TooltipManagerGtk> tooltip_manager_;
 
   scoped_ptr<DropTargetGtk> drop_target_;
 
   // The following factory is used to delay destruction.
   ScopedRunnableMethodFactory<WidgetGtk> close_widget_factory_;
 
   // See description above setter.
   bool delete_on_destroy_;
 
   // See description above make_transparent for details.
   bool transparent_;
 
-  // See description above MakeIgnoreEvents for details.
+  // Makes the window pass all events through to any windows behind it.
+  // Set during SetCreateParams before the widget is created. The actual work of
+  // making the window ignore events is done by ConfigureWidgetForIgnoreEvents.
   bool ignore_events_;
 
   // See note in DropObserver for details on this.
   bool ignore_drag_leave_;
 
   unsigned char opacity_;
 
   // This is non-null during the life of DoDrag and contains the actual data
   // for the drag.
   const OSExchangeDataProviderGtk* drag_data_;
@@ skipping 50 matching lines @@
   bool painted_;
 
   scoped_ptr<InputMethod> input_method_;
 
   DISALLOW_COPY_AND_ASSIGN(WidgetGtk);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_WIDGET_WIDGET_GTK_H_