content: Move render_widget_host_view_gtk to content/

content/browser/renderer_host/render_widget_host_view_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 "chrome/browser/renderer_host/render_widget_host_view_gtk.h"
+#include "content/browser/renderer_host/render_widget_host_view_gtk.h"
 
 // If this gets included after the gtk headers, then a bunch of compiler
 // errors happen because of a "#define Status int" in Xlib.h, which interacts
 // badly with net::URLRequestStatus::Status.
-#include "chrome/common/render_messages.h"
 #include "content/common/view_messages.h"
 
 #include <cairo/cairo.h>
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
 #include <gtk/gtk.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/renderer_host/gtk_im_context_wrapper.h"
-#include "chrome/browser/ui/gtk/gtk_util.h"
-#include "chrome/common/chrome_switches.h"
 #include "content/browser/renderer_host/backing_store_x.h"
+#include "content/browser/renderer_host/gtk_im_context_wrapper.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host.h"
+#include "content/common/content_switches.h"
 #include "content/common/native_web_keyboard_event.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/gtk/WebInputEventFactory.h"
-#include "ui/base/l10n/l10n_util.h"
+#include "ui/base/text/text_elider.h"
 #include "ui/base/x/x11_util.h"
+#include "ui/gfx/gtk_native_view_id_manager.h"
 #include "ui/gfx/gtk_preserve_window.h"
-#include "ui/gfx/gtk_native_view_id_manager.h"
 #include "webkit/glue/webaccessibility.h"
 #include "webkit/glue/webcursor_gtk_data.h"
 #include "webkit/plugins/npapi/webplugin.h"
 
 #if defined(OS_CHROMEOS)
 #include "views/widget/tooltip_window_gtk.h"
 #else
-#include "chrome/browser/renderer_host/gtk_key_bindings_handler.h"
+#include "content/browser/renderer_host/gtk_key_bindings_handler.h"
 #endif  // defined(OS_CHROMEOS)
 
 namespace {
 
 const int kMaxWindowWidth = 4000;
 const int kMaxWindowHeight = 4000;
 const char* kRenderWidgetHostViewKey = "__RENDER_WIDGET_HOST_VIEW__";
 
 // The duration of the fade-out animation. See |overlay_animation_|.
 const int kFadeEffectDuration = 300;
 
 #if defined(OS_CHROMEOS)
 // TODO(davemoore) Under Chromeos we are increasing the rate that the trackpad
 // generates events to get better precisions. Eventually we will coordinate the
 // driver and this setting to ensure they match.
 const float kDefaultScrollPixelsPerTick = 20;
 #else
 // See WebInputEventFactor.cpp for a reason for this being the default
 // scroll size for linux.
 const float kDefaultScrollPixelsPerTick = 160.0f / 3.0f;
 #endif
 
+const GdkColor kBGColor =
+#if defined(NDEBUG)
+    { 0, 0xff * 257, 0xff * 257, 0xff * 257 };
+#else
+    { 0, 0x00 * 257, 0xff * 257, 0x00 * 257 };
+#endif
+
 // Returns the spinning cursor used for loading state.
 GdkCursor* GetMozSpinningCursor() {
   static GdkCursor* moz_spinning_cursor = NULL;
   if (!moz_spinning_cursor) {
     const GdkColor fg = { 0, 0, 0, 0 };
     const GdkColor bg = { 65535, 65535, 65535, 65535 };
     GdkPixmap* source =
         gdk_bitmap_create_from_data(NULL, moz_spinning_bits, 32, 32);
     GdkPixmap* mask =
         gdk_bitmap_create_from_data(NULL, moz_spinning_mask_bits, 32, 32);
@@ skipping 14 matching lines @@
 // static methods.
 class RenderWidgetHostViewGtkWidget {
  public:
   static GtkWidget* CreateNewWidget(RenderWidgetHostViewGtk* host_view) {
     GtkWidget* widget = gtk_preserve_window_new();
     gtk_widget_set_name(widget, "chrome-render-widget-host-view");
     // We manually double-buffer in Paint() because Paint() may or may not be
     // called in repsonse to an "expose-event" signal.
     gtk_widget_set_double_buffered(widget, FALSE);
     gtk_widget_set_redraw_on_allocate(widget, FALSE);
-#if defined(NDEBUG)
-    gtk_widget_modify_bg(widget, GTK_STATE_NORMAL, &gtk_util::kGdkWhite);
-#else
-    gtk_widget_modify_bg(widget, GTK_STATE_NORMAL, &gtk_util::kGdkGreen);
-#endif
+    gtk_widget_modify_bg(widget, GTK_STATE_NORMAL, &kBGColor);
     // Allow the browser window to be resized freely.
     gtk_widget_set_size_request(widget, 0, 0);
 
     gtk_widget_add_events(widget, GDK_EXPOSURE_MASK |
                                   GDK_POINTER_MOTION_MASK |
                                   GDK_BUTTON_PRESS_MASK |
                                   GDK_BUTTON_RELEASE_MASK |
                                   GDK_KEY_PRESS_MASK |
                                   GDK_KEY_RELEASE_MASK |
                                   GDK_FOCUS_CHANGE_MASK |
@@ skipping 692 matching lines @@
 }
 
 void RenderWidgetHostViewGtk::SetTooltipText(const std::wstring& tooltip_text) {
   // Maximum number of characters we allow in a tooltip.
   const int kMaxTooltipLength = 8 << 10;
   // Clamp the tooltip length to kMaxTooltipLength so that we don't
   // accidentally DOS the user with a mega tooltip (since GTK doesn't do
   // this itself).
   // I filed https://bugzilla.gnome.org/show_bug.cgi?id=604641 upstream.
   const string16 clamped_tooltip =
-      l10n_util::TruncateString(WideToUTF16Hack(tooltip_text),
-                                kMaxTooltipLength);
+      ui::TruncateString(WideToUTF16Hack(tooltip_text),
+                         kMaxTooltipLength);
 
   if (clamped_tooltip.empty()) {
     gtk_widget_set_has_tooltip(view_.get(), FALSE);
   } else {
     gtk_widget_set_tooltip_text(view_.get(),
                                 UTF16ToUTF8(clamped_tooltip).c_str());
 #if defined(OS_CHROMEOS)
     tooltip_window_->SetTooltipText(UTF16ToWideHack(clamped_tooltip));
 #endif  // defined(OS_CHROMEOS)
   }
 }
 
 void RenderWidgetHostViewGtk::SelectionChanged(const std::string& text,
                                                const ui::Range& range,
                                                const gfx::Point& start,
                                                const gfx::Point& end) {
   if (!text.empty()) {
     GtkClipboard* x_clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
     gtk_clipboard_set_text(x_clipboard, text.c_str(), text.length());
   }
 }
 
 void RenderWidgetHostViewGtk::ShowingContextMenu(bool showing) {
   is_showing_context_menu_ = showing;
 }
 
 #if !defined(TOOLKIT_VIEWS)
-void RenderWidgetHostViewGtk::AppendInputMethodsContextMenu(MenuGtk* menu) {
-  im_context_->AppendInputMethodsContextMenu(menu);
+GtkWidget* RenderWidgetHostViewGtk::BuildInputMethodsGtkMenu() {
+  return im_context_->BuildInputMethodsGtkMenu();
 }
 #endif
 
 gboolean RenderWidgetHostViewGtk::OnWindowStateEvent(
     GtkWidget* widget,
     GdkEventWindowState* event) {
   if (is_fullscreen_) {
     // If a fullscreen widget got unfullscreened (e.g. by the window manager),
     // close it.
     bool unfullscreened =
@@ skipping 336 matching lines @@
 }
 
 // static
 RenderWidgetHostView*
     RenderWidgetHostView::GetRenderWidgetHostViewFromNativeView(
         gfx::NativeView widget) {
   gpointer user_data = g_object_get_data(G_OBJECT(widget),
                                          kRenderWidgetHostViewKey);
   return reinterpret_cast<RenderWidgetHostView*>(user_data);
 }