Fix remoting_unittests compilation with aura

remoting/host/disconnect_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 "remoting/host/disconnect_window.h"
 
 #include <gtk/gtk.h>
 #include <math.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/ui_strings.h"
 #include "ui/base/gtk/gtk_signal.h"
 
 namespace remoting {
 
-class DisconnectWindowLinux : public DisconnectWindow {
+class DisconnectWindowGtk : public DisconnectWindow {
  public:
-  DisconnectWindowLinux();
-  virtual ~DisconnectWindowLinux();
+  DisconnectWindowGtk();
+  virtual ~DisconnectWindowGtk();
 
   virtual void Show(ChromotingHost* host,
                     const DisconnectCallback& disconnect_callback,
                     const std::string& username) OVERRIDE;
   virtual void Hide() OVERRIDE;
 
  private:
-  CHROMEGTK_CALLBACK_1(DisconnectWindowLinux, gboolean, OnDelete, GdkEvent*);
-  CHROMEGTK_CALLBACK_0(DisconnectWindowLinux, void, OnClicked);
-  CHROMEGTK_CALLBACK_1(DisconnectWindowLinux, gboolean, OnConfigure,
+  CHROMEGTK_CALLBACK_1(DisconnectWindowGtk, gboolean, OnDelete, GdkEvent*);
+  CHROMEGTK_CALLBACK_0(DisconnectWindowGtk, void, OnClicked);
+  CHROMEGTK_CALLBACK_1(DisconnectWindowGtk, gboolean, OnConfigure,
                        GdkEventConfigure*);
-  CHROMEGTK_CALLBACK_1(DisconnectWindowLinux, gboolean, OnButtonPress,
+  CHROMEGTK_CALLBACK_1(DisconnectWindowGtk, gboolean, OnButtonPress,
                        GdkEventButton*);
 
   void CreateWindow(const UiStrings& ui_strings);
 
   DisconnectCallback disconnect_callback_;
   GtkWidget* disconnect_window_;
   GtkWidget* message_;
   GtkWidget* button_;
 
   // Used to distinguish resize events from other types of "configure-event"
   // notifications.
   int current_width_;
   int current_height_;
 
-  DISALLOW_COPY_AND_ASSIGN(DisconnectWindowLinux);
+  DISALLOW_COPY_AND_ASSIGN(DisconnectWindowGtk);
 };
 
-DisconnectWindowLinux::DisconnectWindowLinux()
+DisconnectWindowGtk::DisconnectWindowGtk()
     : disconnect_window_(NULL),
       current_width_(0),
       current_height_(0) {
 }
 
-DisconnectWindowLinux::~DisconnectWindowLinux() {
+DisconnectWindowGtk::~DisconnectWindowGtk() {
 }
 
-void DisconnectWindowLinux::CreateWindow(const UiStrings& ui_strings) {
+void DisconnectWindowGtk::CreateWindow(const UiStrings& ui_strings) {
   if (disconnect_window_) return;
 
   disconnect_window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   GtkWindow* window = GTK_WINDOW(disconnect_window_);
 
   g_signal_connect(disconnect_window_, "delete-event",
                    G_CALLBACK(OnDeleteThunk), this);
   gtk_window_set_title(window, UTF16ToUTF8(ui_strings.product_name).c_str());
   gtk_window_set_resizable(window, FALSE);
 
@@ skipping 49 matching lines @@
   // Override any theme setting for the text color, so that the text is
   // readable against the window's background pixmap.
   PangoAttrList* attributes = pango_attr_list_new();
   PangoAttribute* text_color = pango_attr_foreground_new(0, 0, 0);
   pango_attr_list_insert(attributes, text_color);
   gtk_label_set_attributes(GTK_LABEL(message_), attributes);
 
   gtk_widget_show_all(disconnect_window_);
 }
 
-void DisconnectWindowLinux::Show(ChromotingHost* host,
+void DisconnectWindowGtk::Show(ChromotingHost* host,
                                  const DisconnectCallback& disconnect_callback,
                                  const std::string& username) {
   disconnect_callback_ = disconnect_callback;
   CreateWindow(host->ui_strings());
 
   string16 text = ReplaceStringPlaceholders(
       host->ui_strings().disconnect_message, UTF8ToUTF16(username), NULL);
   gtk_label_set_text(GTK_LABEL(message_), UTF16ToUTF8(text).c_str());
   gtk_window_present(GTK_WINDOW(disconnect_window_));
 }
 
-void DisconnectWindowLinux::Hide() {
+void DisconnectWindowGtk::Hide() {
   if (disconnect_window_) {
     gtk_widget_destroy(disconnect_window_);
     disconnect_window_ = NULL;
   }
 }
 
-void DisconnectWindowLinux::OnClicked(GtkWidget* button) {
+void DisconnectWindowGtk::OnClicked(GtkWidget* button) {
   CHECK(!disconnect_callback_.is_null());
 
   disconnect_callback_.Run();
   Hide();
 }
 
-gboolean DisconnectWindowLinux::OnDelete(GtkWidget* window, GdkEvent* event) {
+gboolean DisconnectWindowGtk::OnDelete(GtkWidget* window, GdkEvent* event) {
   CHECK(!disconnect_callback_.is_null());
 
   disconnect_callback_.Run();
   Hide();
 
   return TRUE;
 }
 
 namespace {
 // Helper function for creating a rectangular path with rounded corners, as
 // Cairo doesn't have this facility.  |radius| is the arc-radius of each
 // corner.  The bounding rectangle extends from (0, 0) to (width, height).
 void AddRoundRectPath(cairo_t* cairo_context, int width, int height,
                       int radius) {
   cairo_new_sub_path(cairo_context);
   cairo_arc(cairo_context, width - radius, radius, radius, -M_PI_2, 0);
   cairo_arc(cairo_context, width - radius, height - radius, radius, 0, M_PI_2);
   cairo_arc(cairo_context, radius, height - radius, radius, M_PI_2, 2 * M_PI_2);
   cairo_arc(cairo_context, radius, radius, radius, 2 * M_PI_2, 3 * M_PI_2);
   cairo_close_path(cairo_context);
 }
 
 }  // namespace
 
-gboolean DisconnectWindowLinux::OnConfigure(GtkWidget* widget,
+gboolean DisconnectWindowGtk::OnConfigure(GtkWidget* widget,
                                             GdkEventConfigure* event) {
   // Only generate bitmaps if the size has actually changed.
   if (event->width == current_width_ && event->height == current_height_)
     return FALSE;
 
   current_width_ = event->width;
   current_height_ = event->height;
 
   // Create the depth 1 pixmap for the window shape.
   GdkPixmap* shape_mask = gdk_pixmap_new(NULL, current_width_, current_height_,
@@ skipping 65 matching lines @@
 
   cairo_destroy(cairo_context);
 
   gdk_window_set_back_pixmap(widget->window, background, FALSE);
   g_object_unref(background);
   gdk_window_invalidate_rect(widget->window, NULL, TRUE);
 
   return FALSE;
 }
 
-gboolean DisconnectWindowLinux::OnButtonPress(GtkWidget* widget,
+gboolean DisconnectWindowGtk::OnButtonPress(GtkWidget* widget,
                                               GdkEventButton* event) {
   gtk_window_begin_move_drag(GTK_WINDOW(disconnect_window_),
                              event->button,
                              event->x_root,
                              event->y_root,
                              event->time);
   return FALSE;
 }
 
 scoped_ptr<DisconnectWindow> DisconnectWindow::Create() {
-  return scoped_ptr<DisconnectWindow>(new DisconnectWindowLinux());
+  return scoped_ptr<DisconnectWindow>(new DisconnectWindowGtk());
 }
 
 }  // namespace remoting