Panels refactor: Support browserless panels on Linux.

chrome/browser/ui/gtk/browser_window_gtk.cc

 // Copyright (c) 2012 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/ui/gtk/browser_window_gtk.h"
 
-#include <dlfcn.h>
 #include <gdk/gdkkeysyms.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/environment.h"
@@ skipping 127 matching lines @@
 // window background to line up with the tab background regardless of whether
 // we're in custom frame mode or not.  Since themes are designed with the
 // custom frame in mind, we need to offset the background when the custom frame
 // is off.
 const int kCustomFrameBackgroundVerticalOffset = 15;
 
 // The timeout in milliseconds before we'll get the true window position with
 // gtk_window_get_position() after the last GTK configure-event signal.
 const int kDebounceTimeoutMilliseconds = 100;
 
-// Ubuntu patches their verrsion of GTK+ so that there is always a
-// gripper in the bottom right corner of the window. We dynamically
-// look up this symbol because it's a non-standard Ubuntu extension to
-// GTK+. We always need to disable this feature since we can't
-// communicate this to WebKit easily.
-typedef void (*gtk_window_set_has_resize_grip_func)(GtkWindow*, gboolean);
-gtk_window_set_has_resize_grip_func gtk_window_set_has_resize_grip_sym;
-
-void EnsureResizeGripFunction() {
-  static bool resize_grip_looked_up = false;
-  if (!resize_grip_looked_up) {
-    resize_grip_looked_up = true;
-    gtk_window_set_has_resize_grip_sym =
-        reinterpret_cast<gtk_window_set_has_resize_grip_func>(
-            dlsym(NULL, "gtk_window_set_has_resize_grip"));
-  }
-}
-
 // Using gtk_window_get_position/size creates a race condition, so only use
 // this to get the initial bounds.  After window creation, we pick up the
 // normal bounds by connecting to the configure-event signal.
 gfx::Rect GetInitialWindowBounds(GtkWindow* window) {
   gint x, y, width, height;
   gtk_window_get_position(window, &x, &y);
   gtk_window_get_size(window, &width, &height);
   return gfx::Rect(x, y, width, height);
 }
 
@@ skipping 46 matching lines @@
         return IDC_MOVE_TAB_PREVIOUS;
       }
       break;
 
     default:
       break;
   }
   return -1;
 }
 
-GdkCursorType GdkWindowEdgeToGdkCursorType(GdkWindowEdge edge) {
-  switch (edge) {
-    case GDK_WINDOW_EDGE_NORTH_WEST:
-      return GDK_TOP_LEFT_CORNER;
-    case GDK_WINDOW_EDGE_NORTH:
-      return GDK_TOP_SIDE;
-    case GDK_WINDOW_EDGE_NORTH_EAST:
-      return GDK_TOP_RIGHT_CORNER;
-    case GDK_WINDOW_EDGE_WEST:
-      return GDK_LEFT_SIDE;
-    case GDK_WINDOW_EDGE_EAST:
-      return GDK_RIGHT_SIDE;
-    case GDK_WINDOW_EDGE_SOUTH_WEST:
-      return GDK_BOTTOM_LEFT_CORNER;
-    case GDK_WINDOW_EDGE_SOUTH:
-      return GDK_BOTTOM_SIDE;
-    case GDK_WINDOW_EDGE_SOUTH_EAST:
-      return GDK_BOTTOM_RIGHT_CORNER;
-    default:
-      NOTREACHED();
-  }
-  return GDK_LAST_CURSOR;
-}
-
 // A helper method for setting the GtkWindow size that should be used in place
 // of calling gtk_window_resize directly.  This is done to avoid a WM "feature"
 // where setting the window size to the monitor size causes the WM to set the
 // EWMH for full screen mode.
 void SetWindowSize(GtkWindow* window, const gfx::Size& size) {
   gfx::Size new_size = size;
 
   gint current_width = 0;
   gint current_height = 0;
   gtk_window_get_size(window, &current_width, &current_height);
@@ skipping 101 matching lines @@
   // compiz, suppress such raises, as they are not necessary in compiz anyway.
   if (ui::GuessWindowManager() == ui::WM_COMPIZ)
     suppress_window_raise_ = true;
 
   window_ = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
   g_object_set_qdata(G_OBJECT(window_), GetBrowserWindowQuarkKey(), this);
   gtk_widget_add_events(GTK_WIDGET(window_), GDK_BUTTON_PRESS_MASK |
                                              GDK_POINTER_MOTION_MASK);
 
   // Disable the resize gripper on Ubuntu.
-  EnsureResizeGripFunction();
-  if (gtk_window_set_has_resize_grip_sym)
-    gtk_window_set_has_resize_grip_sym(GTK_WINDOW(window_), FALSE);
+  gtk_util::DisableResizeGrip(window_);
 
   // Add this window to its own unique window group to allow for
   // window-to-parent modality.
   gtk_window_group_add_window(gtk_window_group_new(), window_);
   g_object_unref(gtk_window_get_group(window_));
 
   // Set up a custom WM_CLASS for some sorts of window types.  This allows
   // task switchers to distinguish between main browser windows and e.g
   // app windows.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
@@ skipping 822 matching lines @@
   else
     gtk_window_activate_key(window_, os_event);
 }
 
 void BrowserWindowGtk::ShowCreateChromeAppShortcutsDialog(
     Profile* profile, const extensions::Extension* app) {
   CreateChromeApplicationShortcutsDialogGtk::Show(window_, profile, app);
 }
 
 void BrowserWindowGtk::Cut() {
-  gtk_util::DoCut(this);
+  gtk_util::DoCut(window_, chrome::GetActiveWebContents(browser_.get()));
 }
 
 void BrowserWindowGtk::Copy() {
-  gtk_util::DoCopy(this);
+  gtk_util::DoCopy(window_, chrome::GetActiveWebContents(browser_.get()));
 }
 
 void BrowserWindowGtk::Paste() {
-  gtk_util::DoPaste(this);
+  gtk_util::DoPaste(window_, chrome::GetActiveWebContents(browser_.get()));
 }
 
 void BrowserWindowGtk::ShowInstant(TabContents* preview) {
   contents_container_->SetPreview(preview);
   MaybeShowBookmarkBar(false);
 }
 
 void BrowserWindowGtk::HideInstant() {
   contents_container_->PopPreview();
   MaybeShowBookmarkBar(false);
@@ skipping 1003 matching lines @@
     }
     return FALSE;
   }
 
   // Update the cursor if we're on the custom frame border.
   GdkWindowEdge edge;
   bool has_hit_edge = GetWindowEdge(static_cast<int>(event->x),
                                     static_cast<int>(event->y), &edge);
   GdkCursorType new_cursor = GDK_LAST_CURSOR;
   if (has_hit_edge)
-    new_cursor = GdkWindowEdgeToGdkCursorType(edge);
+    new_cursor = gtk_util::GdkWindowEdgeToGdkCursorType(edge);
 
   GdkCursorType last_cursor = GDK_LAST_CURSOR;
   if (frame_cursor_)
     last_cursor = frame_cursor_->type;
 
   if (last_cursor != new_cursor) {
     if (has_hit_edge) {
       frame_cursor_ = gfx::GetCursor(new_cursor);
     } else {
       frame_cursor_ = NULL;
@@ skipping 321 matching lines @@
           wm_type == ui::WM_OPENBOX ||
           wm_type == ui::WM_XFWM4);
 }
 
 // static
 BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
   BrowserWindowGtk* browser_window_gtk = new BrowserWindowGtk(browser);
   browser_window_gtk->Init();
   return browser_window_gtk;
 }