(shlib failure) Revert 97750 - content: Move render_widget_host_view_gtk to content/

This also moves some other files:
- OwnedWidgetGtk now goes in ui/base/gtk/
- TruncateString moved from l10n_util:: to ui::
- GtkIMContextWrapper has part of its code split into chrome/ (IDC using code goes in RenderViewContextMenu) and the rest go in content/ (gtk using code goes with GtkIMContextWrapper).
- gtk_key_bindings_handler[_unittest] now goes in content, as it's a utility class to RenderWidgetHostGtk.

BUG=93804
TEST=existing unit tests

Review URL: http://codereview.chromium.org/7669040

TBR=erg@google.com
Review URL: http://codereview.chromium.org/7708017

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@97756 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 0 insertions, 132 deletions

diff --git a/ui/base/gtk/owned_widget_gtk.cc b/ui/base/gtk/owned_widget_gtk.cc
deleted file mode 100644
index 51ee1cc..0000000
--- a/ui/base/gtk/owned_widget_gtk.cc
+++ /dev/null
@@ -1,41 +0,0 @@
-// 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 "ui/base/gtk/owned_widget_gtk.h"
-
-#include <gtk/gtk.h>
-
-#include "base/logging.h"
-
-OwnedWidgetGtk::~OwnedWidgetGtk() {
-  Destroy();
-}
-
-void OwnedWidgetGtk::Own(GtkWidget* widget) {
-  if (!widget)
-    return;
-
-  DCHECK(!widget_);
-  // We want to make sure that Own() was called properly, right after the
-  // widget was created. There should be a floating reference.
-  DCHECK(g_object_is_floating(widget));
-
-  // Sink the floating reference, we should now own this reference.
-  g_object_ref_sink(widget);
-  widget_ = widget;
-}
-
-void OwnedWidgetGtk::Destroy() {
-  if (!widget_)
-    return;
-
-  GtkWidget* widget = widget_;
-  widget_ = NULL;
-  gtk_widget_destroy(widget);
-
-  DCHECK(!g_object_is_floating(widget));
-  // NOTE: Assumes some implementation details about glib internals.
-  DCHECK_EQ(G_OBJECT(widget)->ref_count, 1U);
-  g_object_unref(widget);
-}
diff --git a/ui/base/gtk/owned_widget_gtk.h b/ui/base/gtk/owned_widget_gtk.h
deleted file mode 100644
index d98604e..0000000
--- a/ui/base/gtk/owned_widget_gtk.h
+++ /dev/null
@@ -1,91 +0,0 @@
-// 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.
-
-// This class assists you in dealing with a specific situation when managing
-// ownership between a C++ object and a GTK widget.  It is common to have a
-// C++ object which encapsulates a GtkWidget, and that widget is exposed from
-// the object for use outside of the class.  In this situation, you commonly
-// want the GtkWidget's lifetime to match its C++ object's lifetime.  Using an
-// OwnedWigetGtk will take ownership over the initial reference of the
-// GtkWidget, so that it is "owned" by the C++ object.  Example usage:
-//
-// class FooViewGtk() {
-//  public:
-//   FooViewGtk() { }
-//   ~FooViewGtk() { }
-//   void Init() { vbox_.Own(gtk_vbox_new()); }
-//   GtkWidget* widget() { return vbox_.get() };  // Host my widget!
-//  private:
-//   OwnedWidgetGtk vbox_;
-// };
-//
-// This design will ensure that the widget stays alive from the call to Own()
-// until the call to Destroy().
-//
-// - Details of the problem and OwnedWidgetGtk's solution:
-// In order to make passing ownership more convenient for newly created
-// widgets, GTK has a concept of a "floating" reference.  All GtkObjects (and
-// thus GtkWidgets) inherit from GInitiallyUnowned.  When they are created, the
-// object starts with a reference count of 1, but has its floating flag set.
-// When it is put into a container for the first time, that container will
-// "sink" the floating reference, and the count will still be 1.  Now the
-// container owns the widget, and if we remove the widget from the container,
-// the widget is destroyed.  This style of ownership often causes problems when
-// you have an object encapsulating the widget.  If we just use a raw
-// GtkObject* with no specific ownership management, we push the widget's
-// ownership onto the user of the class.  Now the C++ object can't depend on
-// the widget being valid, since it doesn't manage its lifetime.  If the widget
-// was removed from a container, removing its only reference, it would be
-// destroyed (from the C++ object's perspective) unexpectedly destroyed.  The
-// solution is fairly simple, make sure that the C++ object owns the widget,
-// and thus it is also responsible for destroying it.  This boils down to:
-//   GtkWidget* widget = gtk_widget_new();
-//   g_object_ref_sink(widget);  // Claim the initial floating reference.
-//   ...
-//   gtk_destroy_widget(widget);  // Ask all code to destroy their references.
-//   g_object_unref(widget);  // Destroy the initial reference we had claimed.
-
-#ifndef UI_BASE_GTK_OWNED_WIDGET_GTK_H_
-#define UI_BASE_GTK_OWNED_WIDGET_GTK_H_
-#pragma once
-
-#include "base/basictypes.h"
-
-typedef struct _GtkWidget GtkWidget;
-
-class OwnedWidgetGtk {
- public:
-  // Create an instance that isn't managing any ownership.
-  OwnedWidgetGtk() : widget_(NULL) { }
-  // Create an instance that owns |widget|.
-  explicit OwnedWidgetGtk(GtkWidget* widget) : widget_(NULL) { Own(widget); }
-
-  ~OwnedWidgetGtk();
-
-  // Return the currently owned widget, or NULL if no widget is owned.
-  GtkWidget* get() const { return widget_; }
-  GtkWidget* operator->() const { return widget_; }
-
-  // Takes ownership of a widget, by taking the initial floating reference of
-  // the GtkWidget. It is expected that Own() is called right after the widget
-  // has been created, and before any other references to the widget might have
-  // been added. It is valid to never call Own(), in which case Destroy() will
-  // do nothing. If Own() has been called, you must explicitly call Destroy().
-  void Own(GtkWidget* widget);
-
-  // You may call Destroy() after you have called Own(). Calling Destroy()
-  // will call gtk_widget_destroy(), and drop our reference to the widget.
-  // Destroy() is also called in this object's destructor.
-  // After a call to Destroy(), you may call Own() again. NOTE: It is expected
-  // that after gtk_widget_destroy we will be holding the only reference left
-  // on the object. We assert this in debug mode to help catch any leaks.
-  void Destroy();
-
- private:
-  GtkWidget* widget_;
-
-  DISALLOW_COPY_AND_ASSIGN(OwnedWidgetGtk);
-};
-
-#endif  // UI_BASE_GTK_OWNED_WIDGET_GTK_H_