GTK: More transitions to thunk definition macros.

chrome/browser/tab_contents/tab_contents_view_gtk.cc

 // Copyright (c) 2010 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 "chrome/browser/tab_contents/tab_contents_view_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
@@ skipping 96 matching lines @@
   return new TabContentsViewGtk(tab_contents);
 }
 
 TabContentsViewGtk::TabContentsViewGtk(TabContents* tab_contents)
     : TabContentsView(tab_contents),
       floating_(gtk_floating_container_new()),
       expanded_(gtk_expanded_container_new()),
       constrained_window_(NULL) {
   gtk_widget_set_name(expanded_, "chrome-tab-contents-view");
   g_signal_connect(expanded_, "size-allocate",
-                   G_CALLBACK(OnSizeAllocate), this);
+                   G_CALLBACK(OnSizeAllocateThunk), this);
   g_signal_connect(expanded_, "child-size-request",
-                   G_CALLBACK(OnChildSizeRequest), this);
+                   G_CALLBACK(OnChildSizeRequestThunk), this);
   g_signal_connect(floating_.get(), "set-floating-position",
-                   G_CALLBACK(OnSetFloatingPosition), this);
+                   G_CALLBACK(OnSetFloatingPositionThunk), this);
 
   gtk_container_add(GTK_CONTAINER(floating_.get()), expanded_);
   gtk_widget_show(expanded_);
   gtk_widget_show(floating_.get());
   registrar_.Add(this, NotificationType::TAB_CONTENTS_CONNECTED,
                  Source<TabContents>(tab_contents));
   drag_source_.reset(new TabContentsDragSource(this));
 }
 
 TabContentsViewGtk::~TabContentsViewGtk() {
@@ skipping 42 matching lines @@
                    G_CALLBACK(OnFocus), tab_contents());
   g_signal_connect(content_view, "leave-notify-event",
                    G_CALLBACK(OnLeaveNotify), tab_contents());
   g_signal_connect(content_view, "motion-notify-event",
                    G_CALLBACK(OnMouseMove), tab_contents());
   g_signal_connect(content_view, "scroll-event",
                    G_CALLBACK(OnMouseScroll), tab_contents());
   gtk_widget_add_events(content_view, GDK_LEAVE_NOTIFY_MASK |
                         GDK_POINTER_MOTION_MASK);
   g_signal_connect(content_view, "button-press-event",
-                   G_CALLBACK(OnMouseDown), this);
+                   G_CALLBACK(OnMouseDownThunk), this);
   InsertIntoContentArea(content_view);
 
   // Renderer target DnD.
   drag_dest_.reset(new WebDragDestGtk(tab_contents(), content_view));
 
   return view;
 }
 
 gfx::NativeView TabContentsViewGtk::GetNativeView() const {
   return floating_.get();
@@ skipping 135 matching lines @@
   // TODO(snej): Make use of the WebDragOperationsMask somehow
 }
 
 // -----------------------------------------------------------------------------
 
 void TabContentsViewGtk::InsertIntoContentArea(GtkWidget* widget) {
   gtk_container_add(GTK_CONTAINER(expanded_), widget);
 }
 
 gboolean TabContentsViewGtk::OnMouseDown(GtkWidget* widget,
-    GdkEventButton* event, TabContentsViewGtk* view) {
-  view->last_mouse_down_ = *event;
+                                         GdkEventButton* event) {
+  last_mouse_down_ = *event;
   return FALSE;
 }
 
 void TabContentsViewGtk::OnChildSizeRequest(GtkWidget* widget,
                                             GtkWidget* child,
-                                            GtkRequisition* requisition,
-                                            TabContentsViewGtk* view) {
-  if (view->tab_contents()->delegate()) {
+                                            GtkRequisition* requisition) {
+  if (tab_contents()->delegate()) {
     requisition->height +=
-        view->tab_contents()->delegate()->GetExtraRenderViewHeight();
+        tab_contents()->delegate()->GetExtraRenderViewHeight();
   }
 }
 
 void TabContentsViewGtk::OnSizeAllocate(GtkWidget* widget,
-                                        GtkAllocation* allocation,
-                                        TabContentsViewGtk* view) {
+                                        GtkAllocation* allocation) {
   int width = allocation->width;
   int height = allocation->height;
   // |delegate()| can be NULL here during browser teardown.
-  if (view->tab_contents()->delegate())
-    height += view->tab_contents()->delegate()->GetExtraRenderViewHeight();
+  if (tab_contents()->delegate())
+    height += tab_contents()->delegate()->GetExtraRenderViewHeight();
   gfx::Size size(width, height);
-  view->requested_size_ = size;
+  requested_size_ = size;
 
   // We manually tell our RWHV to resize the renderer content.  This avoids
   // spurious resizes from GTK+.
-  RenderWidgetHostView* rwhv = view->tab_contents()->GetRenderWidgetHostView();
+  RenderWidgetHostView* rwhv = tab_contents()->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->SetSize(size);
-  if (view->tab_contents()->interstitial_page())
-    view->tab_contents()->interstitial_page()->SetSize(size);
+  if (tab_contents()->interstitial_page())
+    tab_contents()->interstitial_page()->SetSize(size);
 }
 
-// static
 void TabContentsViewGtk::OnSetFloatingPosition(
-    GtkFloatingContainer* floating_container, GtkAllocation* allocation,
-    TabContentsViewGtk* tab_contents_view) {
+    GtkWidget* floating_container, GtkAllocation* allocation) {
   // Place each ConstrainedWindow in the center of the view.
   int half_view_width = std::max((allocation->x + allocation->width) / 2, 0);
   int half_view_height = std::max((allocation->y + allocation->height) / 2, 0);
-  if (tab_contents_view->constrained_window_) {
-    GtkWidget* widget = tab_contents_view->constrained_window_->widget();
-    DCHECK(widget->parent == tab_contents_view->floating_.get());
+  if (constrained_window_) {
+    GtkWidget* widget = constrained_window_->widget();
+    DCHECK(widget->parent == floating_.get());
 
     GtkRequisition requisition;
     gtk_widget_size_request(widget, &requisition);
 
     GValue value = { 0, };
     g_value_init(&value, G_TYPE_INT);
 
     int child_x = std::max(half_view_width - (requisition.width / 2), 0);
     g_value_set_int(&value, child_x);
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "x", &value);
 
     int child_y = std::max(half_view_height - (requisition.height / 2), 0);
     g_value_set_int(&value, child_y);
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "y", &value);
     g_value_unset(&value);
   }
 }