Re-land:

views/window/window_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/window/window_gtk.h"
 
 #include "base/i18n/rtl.h"
 #include "base/utf_string_conversions.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/path.h"
@@ skipping 61 matching lines @@
       break;
   }
   // Default to something defaultish.
   return GDK_LEFT_PTR;
 }
 
 }  // namespace
 
 namespace views {
 
-WindowGtk::WindowGtk()
-    : ALLOW_THIS_IN_INITIALIZER_LIST(delegate_(this)),
+WindowGtk::WindowGtk(internal::NativeWindowDelegate* delegate)
+    : WidgetGtk(delegate->AsNativeWidgetDelegate()),
+      delegate_(delegate),
       window_state_(GDK_WINDOW_STATE_WITHDRAWN),
       window_closed_(false) {
-  SetNativeWindow(this);
   is_window_ = true;
 }
 
 WindowGtk::~WindowGtk() {
 }
 
-// static
-void Window::CloseAllSecondaryWindows() {
-  GList* windows = gtk_window_list_toplevels();
-  for (GList* window = windows; window;
-       window = g_list_next(window)) {
-    Window::CloseSecondaryWidget(
-        NativeWidget::GetNativeWidgetForNativeView(
-            GTK_WIDGET(window->data))->GetWidget());
-  }
-  g_list_free(windows);
-}
-
-Window* WindowGtk::AsWindow() {
-  return this;
-}
-
-const Window* WindowGtk::AsWindow() const {
-  return this;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // WindowGtk, WidgetGtk overrides:
 
 gboolean WindowGtk::OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
   GdkEventButton transformed_event = *event;
   MouseEvent mouse_event(TransformEvent(&transformed_event));
 
   int hittest_code =
       GetWindow()->non_client_view()->NonClientHitTest(mouse_event.location());
   switch (hittest_code) {
     case HTCAPTION: {
       // Start dragging if the mouse event is a single click and *not* a right
       // click. If it is a right click, then pass it through to
       // WidgetGtk::OnButtonPress so that View class can show ContextMenu upon a
       // mouse release event. We only start drag on single clicks as we get a
       // crash in Gtk on double/triple clicks.
       if (event->type == GDK_BUTTON_PRESS &&
           !mouse_event.IsOnlyRightMouseButton()) {
         gfx::Point screen_point(event->x, event->y);
-        View::ConvertPointToScreen(GetRootView(), &screen_point);
+        View::ConvertPointToScreen(GetWindow()->GetRootView(), &screen_point);
         gtk_window_begin_move_drag(GetNativeWindow(), event->button,
                                    screen_point.x(), screen_point.y(),
                                    event->time);
         return TRUE;
       }
       break;
     }
     case HTBOTTOM:
     case HTBOTTOMLEFT:
     case HTBOTTOMRIGHT:
     case HTGROWBOX:
     case HTLEFT:
     case HTRIGHT:
     case HTTOP:
     case HTTOPLEFT:
     case HTTOPRIGHT: {
       gfx::Point screen_point(event->x, event->y);
-      View::ConvertPointToScreen(GetRootView(), &screen_point);
+      View::ConvertPointToScreen(GetWindow()->GetRootView(), &screen_point);
       // TODO(beng): figure out how to get a good minimum size.
       gtk_widget_set_size_request(GetNativeView(), 100, 100);
       gtk_window_begin_resize_drag(GetNativeWindow(),
                                    HitTestCodeToGDKWindowEdge(hittest_code),
                                    event->button, screen_point.x(),
                                    screen_point.y(), event->time);
       return TRUE;
     }
     default:
       // Everything else falls into standard client event handling...
@@ skipping 53 matching lines @@
 
   return WidgetGtk::OnLeaveNotify(widget, event);
 }
 
 void WindowGtk::IsActiveChanged() {
   WidgetGtk::IsActiveChanged();
   delegate_->OnNativeWindowActivationChanged(IsActive());
 }
 
 void WindowGtk::InitNativeWidget(const Widget::InitParams& params) {
-  if (params.parent)
-    make_transient_to_parent();
-
   WidgetGtk::InitNativeWidget(params);
 
   g_signal_connect(G_OBJECT(GetNativeWindow()), "configure-event",
                    G_CALLBACK(CallConfigureEvent), this);
   g_signal_connect(G_OBJECT(GetNativeWindow()), "window-state-event",
                    G_CALLBACK(CallWindowStateEvent), this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowGtk, NativeWindow implementation:
@@ skipping 66 matching lines @@
 void WindowGtk::SetAccessibleName(const std::wstring& name) {
 }
 
 void WindowGtk::SetAccessibleRole(ui::AccessibilityTypes::Role role) {
 }
 
 void WindowGtk::SetAccessibleState(ui::AccessibilityTypes::State state) {
 }
 
 Window* WindowGtk::GetWindow() {
-  return this;
+  return delegate_->AsWindow();
+}
+
+const Window* WindowGtk::GetWindow() const {
+  return delegate_->AsWindow();
 }
 
 void WindowGtk::SetWindowBounds(const gfx::Rect& bounds,
                                 gfx::NativeWindow other_window) {
   // TODO: need to deal with other_window.
   WidgetGtk::SetBounds(bounds);
 }
 
 void WindowGtk::HideWindow() {
-  Hide();
+  GetWindow()->Hide();
 }
 
 void WindowGtk::Activate() {
   gtk_window_present(GTK_WINDOW(GetNativeView()));
 }
 
 void WindowGtk::Deactivate() {
   gdk_window_lower(GTK_WIDGET(GetNativeView())->window);
 }
 
@@ skipping 38 matching lines @@
 }
 
 bool WindowGtk::IsFullscreen() const {
   return window_state_ & GDK_WINDOW_STATE_FULLSCREEN;
 }
 
 void WindowGtk::SetUseDragFrame(bool use_drag_frame) {
   NOTIMPLEMENTED();
 }
 
+NonClientFrameView* WindowGtk::CreateFrameViewForWindow() {
+  return new CustomFrameView(delegate_->AsWindow());
+}
+
 void WindowGtk::SetAlwaysOnTop(bool always_on_top) {
   gtk_window_set_keep_above(GetNativeWindow(), always_on_top);
 }
 
-bool WindowGtk::IsAppWindow() const {
-  return false;
-}
-
-NonClientFrameView* WindowGtk::CreateFrameViewForWindow() {
-  // TODO(erg): Always use a custom frame view? Are there cases where we let
-  // the window manager deal with the X11 equivalent of the "non-client" area?
-  return new CustomFrameView(this);
-}
-
 void WindowGtk::UpdateFrameAfterFrameChange() {
   // We currently don't support different frame types on Gtk, so we don't
   // need to implement this.
   NOTIMPLEMENTED();
 }
 
 gfx::NativeWindow WindowGtk::GetNativeWindow() const {
   return GTK_WINDOW(GetNativeView());
 }
 
 bool WindowGtk::ShouldUseNativeFrame() const {
   return false;
 }
 
 void WindowGtk::FrameTypeChanged() {
   // This is called when the Theme has changed, so forward the event to the root
   // widget.
-  ThemeChanged();
-  GetRootView()->SchedulePaint();
+  GetWidget()->ThemeChanged();
+  GetWidget()->GetRootView()->SchedulePaint();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowGtk, private:
 
 // static
 gboolean WindowGtk::CallConfigureEvent(GtkWidget* widget,
                                        GdkEventConfigure* event,
                                        WindowGtk* window_gtk) {
   return window_gtk->OnConfigureEvent(widget, event);
 }
 
 // static
 gboolean WindowGtk::CallWindowStateEvent(GtkWidget* widget,
                                          GdkEventWindowState* event,
                                          WindowGtk* window_gtk) {
   return window_gtk->OnWindowStateEvent(widget, event);
 }
 
 void WindowGtk::SaveWindowPosition() {
   // The delegate may have gone away on us.
   if (!GetWindow()->window_delegate())
     return;
 
   bool maximized = window_state_ & GDK_WINDOW_STATE_MAXIMIZED;
-  GetWindow()->window_delegate()->SaveWindowPlacement(GetBounds(), maximized);
+  GetWindow()->window_delegate()->SaveWindowPlacement(
+      GetWidget()->GetWindowScreenBounds(),
+      maximized);
 }
 
 void WindowGtk::OnDestroy(GtkWidget* widget) {
   delegate_->OnNativeWindowDestroying();
   WidgetGtk::OnDestroy(widget);
   delegate_->OnNativeWindowDestroyed();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWindow, public:
 
 // static
-Window* NativeWindow::CreateNativeWindow() {
-  return new WindowGtk;
+NativeWindow* NativeWindow::CreateNativeWindow(
+    internal::NativeWindowDelegate* delegate) {
+  return new WindowGtk(delegate);
 }
 
 }  // namespace views
+