Revert 91710 - Fix flicker on tab switch on chromeos.

views/controls/native/native_view_host_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/controls/native/native_view_host_gtk.h"
 
 #include <gtk/gtk.h>
 #include <algorithm>
 
 #include "base/logging.h"
@@ skipping 67 matching lines @@
 void UnblockFocusSignals(GtkWidget* widget, gpointer data) {
   if (!widget)
     return;
   InitSignalIds();
   UnblockSignal(widget, focus_in_event_signal_id_);
   UnblockSignal(widget, focus_out_event_signal_id_);
   if (GTK_IS_CONTAINER(widget))
     gtk_container_foreach(GTK_CONTAINER(widget), UnblockFocusSignals, data);
 }
 
-// Removes |child| from |parent|.
-void RemoveFromParent(GtkWidget* child, gpointer parent) {
-  gtk_container_remove(GTK_CONTAINER(parent), child);
-}
-
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeViewHostGtk, public:
 
 NativeViewHostGtk::NativeViewHostGtk(NativeViewHost* host)
     : host_(host),
       installed_clip_(false),
       destroy_signal_id_(0),
       focus_signal_id_(0),
       fixed_(NULL) {
   CreateFixed(false);
 }
 
 NativeViewHostGtk::~NativeViewHostGtk() {
-  if (fixed_) {
-    gtk_container_foreach(GTK_CONTAINER(fixed_), RemoveFromParent, fixed_);
+  if (fixed_)
     gtk_widget_destroy(fixed_);
-  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeViewHostGtk, NativeViewHostWrapper implementation:
 
 void NativeViewHostGtk::NativeViewAttached() {
-  AttachHostWidget();
-
-  GtkWidget* host_widget = host_->native_view();
+  DCHECK(host_->native_view());
+  if (gtk_widget_get_parent(host_->native_view()))
+    gtk_widget_reparent(host_->native_view(), fixed_);
+  else
+    gtk_container_add(GTK_CONTAINER(fixed_), host_->native_view());
 
   // Let the widget know that the native component has been painted.
-  views::NativeWidgetGtk::RegisterChildExposeHandler(host_widget);
+  views::NativeWidgetGtk::RegisterChildExposeHandler(host_->native_view());
 
   if (!destroy_signal_id_) {
-    destroy_signal_id_ = g_signal_connect(host_widget,
+    destroy_signal_id_ = g_signal_connect(host_->native_view(),
                                           "destroy", G_CALLBACK(CallDestroy),
                                           this);
   }
 
   if (!focus_signal_id_) {
-    focus_signal_id_ = g_signal_connect(host_widget,
+    focus_signal_id_ = g_signal_connect(host_->native_view(),
                                         "focus-in-event",
                                         G_CALLBACK(CallFocusIn), this);
   }
 
   // Always layout though.
   host_->Layout();
 
+  // We own the native view as long as it's attached, so that we can safely
+  // reparent it in multiple passes.
+  gtk_widget_ref(host_->native_view());
+
   // TODO(port): figure out focus.
 }
 
 void NativeViewHostGtk::NativeViewDetaching(bool destroyed) {
-  GtkWidget* host_widget = host_->native_view();
-  DCHECK(host_widget);
+  DCHECK(host_->native_view());
 
-  g_signal_handler_disconnect(G_OBJECT(host_widget), destroy_signal_id_);
+  g_signal_handler_disconnect(G_OBJECT(host_->native_view()),
+                              destroy_signal_id_);
   destroy_signal_id_ = 0;
 
-  g_signal_handler_disconnect(G_OBJECT(host_widget), focus_signal_id_);
+  g_signal_handler_disconnect(G_OBJECT(host_->native_view()),
+                              focus_signal_id_);
   focus_signal_id_ = 0;
 
   installed_clip_ = false;
+
+  if (fixed_ && !destroyed) {
+    DCHECK_NE(static_cast<gfx::NativeView>(NULL),
+              gtk_widget_get_parent(host_->native_view()));
+    gtk_container_remove(GTK_CONTAINER(fixed_), host_->native_view());
+    DCHECK_EQ(
+        0U, g_list_length(gtk_container_get_children(GTK_CONTAINER(fixed_))));
+  }
+
+  g_object_unref(G_OBJECT(host_->native_view()));
 }
 
 void NativeViewHostGtk::AddedToWidget() {
   if (!fixed_)
     CreateFixed(false);
   if (gtk_widget_get_parent(fixed_))
     GetHostWidget()->ReparentChild(fixed_);
   else
     GetHostWidget()->AddChild(fixed_);
 
   if (!host_->native_view())
     return;
 
-  AttachHostWidget();
+  if (gtk_widget_get_parent(host_->native_view()))
+    gtk_widget_reparent(host_->native_view(), fixed_);
+  else
+    gtk_container_add(GTK_CONTAINER(fixed_), host_->native_view());
 
-  if (host_->IsVisibleInRootView()) {
-    gtk_widget_show(host_->native_view());
+  if (host_->IsVisibleInRootView())
     gtk_widget_show(fixed_);
-  } else {
+  else
     gtk_widget_hide(fixed_);
-  }
   host_->Layout();
 }
 
 void NativeViewHostGtk::RemovedFromWidget() {
   if (!host_->native_view())
     return;
   DestroyFixed();
 }
 
 void NativeViewHostGtk::InstallClip(int x, int y, int w, int h) {
@@ skipping 32 matching lines @@
   int child_h = h;
   if (installed_clip_) {
     child_x = -installed_clip_bounds_.x();
     child_y = -installed_clip_bounds_.y();
     fixed_x += -child_x;
     fixed_y += -child_y;
     fixed_w = std::min(installed_clip_bounds_.width(), w);
     fixed_h = std::min(installed_clip_bounds_.height(), h);
   }
 
-  GtkWidget* host_widget = host_->native_view();
   // Don't call gtk_widget_size_allocate now, as we're possibly in the
   // middle of a re-size, and it kicks off another re-size, and you
   // get flashing.  Instead, we'll set the desired size as properties
   // on the widget and queue the re-size.
-  gtk_views_fixed_set_widget_size(host_widget, child_w, child_h);
-  gtk_fixed_move(GTK_FIXED(fixed_), host_widget, child_x, child_y);
+  gtk_views_fixed_set_widget_size(host_->native_view(), child_w, child_h);
+  gtk_fixed_move(GTK_FIXED(fixed_), host_->native_view(), child_x, child_y);
 
   // Size and place the fixed_.
   GetHostWidget()->PositionChild(fixed_, fixed_x, fixed_y, fixed_w, fixed_h);
 
-  gtk_widget_show(host_widget);
   gtk_widget_show(fixed_);
+  gtk_widget_show(host_->native_view());
 }
 
 void NativeViewHostGtk::HideWidget() {
   if (fixed_)
     gtk_widget_hide(fixed_);
 }
 
 void NativeViewHostGtk::SetFocus() {
-  GtkWidget* host_widget = host_->native_view();
-  DCHECK(host_widget);
-  gtk_widget_grab_focus(host_widget);
+  DCHECK(host_->native_view());
+  gtk_widget_grab_focus(host_->native_view());
 }
 
 gfx::NativeViewAccessible NativeViewHostGtk::GetNativeViewAccessible() {
   return NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeViewHostGtk, private:
 
 void NativeViewHostGtk::CreateFixed(bool needs_window) {
@@ skipping 13 matching lines @@
     // restore focus after we create the new fixed_. This way focus hasn't
     // really moved.
     gtk_widget_grab_focus(GetHostWidget()->GetNativeView());
   }
 
   DestroyFixed();
 
   fixed_ = gtk_views_fixed_new();
   gtk_widget_set_name(fixed_, "views-native-view-host-fixed");
   gtk_fixed_set_has_window(GTK_FIXED(fixed_), needs_window);
-
   // Defeat refcounting. We need to own the fixed.
   gtk_widget_ref(fixed_);
 
   NativeWidgetGtk* widget_gtk = GetHostWidget();
-  if (widget_gtk) {
+  if (widget_gtk)
     widget_gtk->AddChild(fixed_);
-    // Clear the background so we don't get flicker.
-    gtk_widget_realize(fixed_);
-    gdk_window_set_back_pixmap(fixed_->window, NULL, false);
-  }
 
   if (host_->native_view())
-    AttachHostWidget();
+    gtk_container_add(GTK_CONTAINER(fixed_), host_->native_view());
 
-  if (widget_gtk && host_->native_view() && focused_widget)
+  if (widget_gtk && host_->native_view() && focused_widget) {
     gtk_widget_grab_focus(focused_widget);
-
+  }
   if (focus_event_blocked) {
     // Unblocking a signal handler that is not blocked fails.
     // Unblock only when it's unblocked.
     UnblockFocusSignals(GetHostWidget()->GetNativeView(), NULL);
   }
 }
 
 void NativeViewHostGtk::DestroyFixed() {
   if (!fixed_)
     return;
 
   gtk_widget_hide(fixed_);
-  gtk_container_foreach(GTK_CONTAINER(fixed_), RemoveFromParent, fixed_);
   GetHostWidget()->RemoveChild(fixed_);
 
+  if (host_->native_view()) {
+    // We can safely remove the widget from its container since we own the
+    // widget from the moment it is attached.
+    gtk_container_remove(GTK_CONTAINER(fixed_), host_->native_view());
+  }
   // fixed_ should not have any children this point.
   DCHECK_EQ(0U,
             g_list_length(gtk_container_get_children(GTK_CONTAINER(fixed_))));
   gtk_widget_destroy(fixed_);
   fixed_ = NULL;
 }
 
 NativeWidgetGtk* NativeViewHostGtk::GetHostWidget() const {
   return static_cast<NativeWidgetGtk*>(host_->GetWidget()->native_widget());
 }
 
 GtkWidget* NativeViewHostGtk::GetFocusedDescendant() {
   if (!fixed_)
     return NULL;
   NativeWidgetGtk* host = GetHostWidget();
   if (!host)
     return NULL;
   GtkWidget* top_level = gtk_widget_get_toplevel(host->GetNativeView());
   if (!top_level || !GTK_IS_WINDOW(top_level))
     return NULL;
   GtkWidget* focused = gtk_window_get_focus(GTK_WINDOW(top_level));
   if (!focused)
     return NULL;
   return (focused == fixed_ || gtk_widget_is_ancestor(focused, fixed_)) ?
       focused : NULL;
 }
 
-void NativeViewHostGtk::AttachHostWidget() {
-  GtkWidget* host_widget = host_->native_view();
-  DCHECK(host_widget);
-
-  GtkWidget* host_parent = gtk_widget_get_parent(host_widget);
-  bool parent_changed = true;
-  if (host_parent) {
-    if (host_parent != fixed_)
-      gtk_widget_reparent(host_widget, fixed_);
-    else
-      parent_changed = false;
-  } else {
-    gtk_container_add(GTK_CONTAINER(fixed_), host_widget);
-  }
-
-  if (parent_changed) {
-    // We need to clear the background so we don't get flicker on tab switching.
-    // To do that we must realize the widget if it's not already.
-    if (!GTK_WIDGET_REALIZED(host_widget))
-      gtk_widget_realize(host_widget);
-    gdk_window_set_back_pixmap(host_widget->window, NULL, false);
-  }
-}
-
 // static
 void NativeViewHostGtk::CallDestroy(GtkObject* object,
                                     NativeViewHostGtk* host) {
   host->host_->NativeViewDestroyed();
 }
 
 // static
 gboolean NativeViewHostGtk::CallFocusIn(GtkWidget* widget,
                                         GdkEventFocus* event,
                                         NativeViewHostGtk* host) {
@@ skipping 16 matching lines @@
 // static
 NativeViewHostWrapper* NativeViewHostWrapper::CreateWrapper(
     NativeViewHost* host) {
   if (Widget::IsPureViews() &&
       views::ViewsDelegate::views_delegate->GetDefaultParentView())
     return new NativeViewHostViews(host);
   return new NativeViewHostGtk(host);
 }
 
 }  // namespace views