WebUI: Change DOMUI to WebUI in two chromeos classes.

chrome/browser/chromeos/views/webui_menu_widget.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/chromeos/views/domui_menu_widget.h"
+#include "chrome/browser/chromeos/views/webui_menu_widget.h"
 
 #include <algorithm>
 
 #include "base/stringprintf.h"
 #include "base/singleton.h"
 #include "base/task.h"
 #include "chrome/browser/chromeos/views/menu_locator.h"
 #include "chrome/browser/chromeos/views/native_menu_domui.h"
 #include "chrome/browser/chromeos/wm_ipc.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
@@ skipping 81 matching lines @@
     gfx::Insets insets = host->GetInsets();
     gfx::Size size = host->GetChildViewAt(0)->GetPreferredSize();
     return gfx::Size(size.width() + insets.width(),
                      size.height() + insets.height());
   }
 
   DISALLOW_COPY_AND_ASSIGN(InsetsLayout);
 };
 
 // A gtk widget key used to test if a given WidgetGtk instance is
-// DOMUIMenuWidgetKey.
-const char* kDOMUIMenuWidgetKey = "__DOMUI_MENU_WIDGET__";
+// a WebUIMenuWidgetKey.
+const char* kWebUIMenuWidgetKey = "__WEBUI_MENU_WIDGET__";
 
 }  // namespace
 
 namespace chromeos {
 
 // static
-DOMUIMenuWidget* DOMUIMenuWidget::FindDOMUIMenuWidget(gfx::NativeView native) {
+WebUIMenuWidget* WebUIMenuWidget::FindWebUIMenuWidget(gfx::NativeView native) {
   DCHECK(native);
   native = gtk_widget_get_toplevel(native);
   if (!native)
     return NULL;
-  return static_cast<chromeos::DOMUIMenuWidget*>(
-      g_object_get_data(G_OBJECT(native), kDOMUIMenuWidgetKey));
+  return static_cast<chromeos::WebUIMenuWidget*>(
+      g_object_get_data(G_OBJECT(native), kWebUIMenuWidgetKey));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// DOMUIMenuWidget public:
+// WebUIMenuWidget public:
 
-DOMUIMenuWidget::DOMUIMenuWidget(chromeos::NativeMenuDOMUI* domui_menu,
+WebUIMenuWidget::WebUIMenuWidget(chromeos::NativeMenuDOMUI* domui_menu,
                                  bool root)
     : views::WidgetGtk(views::WidgetGtk::TYPE_POPUP),
       domui_menu_(domui_menu),
       dom_view_(NULL),
       did_input_grab_(false),
       is_root_(root) {
   DCHECK(domui_menu_);
   // TODO(oshima): Disabling transparent until we migrate bookmark
   // menus to DOMUI.  See crosbug.com/7718.
   // MakeTransparent();
 }
 
-DOMUIMenuWidget::~DOMUIMenuWidget() {
+WebUIMenuWidget::~WebUIMenuWidget() {
 }
 
-void DOMUIMenuWidget::Init(gfx::NativeView parent, const gfx::Rect& bounds) {
+void WebUIMenuWidget::Init(gfx::NativeView parent, const gfx::Rect& bounds) {
   WidgetGtk::Init(parent, bounds);
   gtk_window_set_destroy_with_parent(GTK_WINDOW(GetNativeView()), TRUE);
   gtk_window_set_type_hint(GTK_WINDOW(GetNativeView()),
                            GDK_WINDOW_TYPE_HINT_MENU);
-  g_object_set_data(G_OBJECT(GetNativeView()), kDOMUIMenuWidgetKey, this);
+  g_object_set_data(G_OBJECT(GetNativeView()), kWebUIMenuWidgetKey, this);
 }
 
-void DOMUIMenuWidget::Hide() {
+void WebUIMenuWidget::Hide() {
   ReleaseGrab();
   WidgetGtk::Hide();
   // Clears the content.
   ExecuteJavascript(L"updateModel({'items':[]})");
 }
 
-void DOMUIMenuWidget::Close() {
+void WebUIMenuWidget::Close() {
   if (dom_view_ != NULL) {
     dom_view_->GetParent()->RemoveChildView(dom_view_);
     delete dom_view_;
     dom_view_ = NULL;
   }
 
   // Detach the domui_menu_ which is being deleted.
   domui_menu_ = NULL;
   views::WidgetGtk::Close();
 }
 
-void DOMUIMenuWidget::ReleaseGrab() {
+void WebUIMenuWidget::ReleaseGrab() {
   WidgetGtk::ReleaseGrab();
   if (did_input_grab_) {
     did_input_grab_ = false;
     gdk_pointer_ungrab(GDK_CURRENT_TIME);
     gdk_keyboard_ungrab(GDK_CURRENT_TIME);
 
     ClearGrabWidget();
   }
 }
 
-gboolean DOMUIMenuWidget::OnGrabBrokeEvent(GtkWidget* widget,
+gboolean WebUIMenuWidget::OnGrabBrokeEvent(GtkWidget* widget,
                                            GdkEvent* event) {
   did_input_grab_ = false;
   Hide();
   return WidgetGtk::OnGrabBrokeEvent(widget, event);
 }
 
-void DOMUIMenuWidget::OnSizeAllocate(GtkWidget* widget,
+void WebUIMenuWidget::OnSizeAllocate(GtkWidget* widget,
                                      GtkAllocation* allocation) {
   views::WidgetGtk::OnSizeAllocate(widget, allocation);
   // Adjust location when menu gets resized.
   gfx::Rect bounds;
   GetBounds(&bounds, false);
   // Don't move until the menu gets contents.
   if (bounds.height() > 1) {
     menu_locator_->Move(this);
     domui_menu_->InputIsReady();
   }
 }
 
 gboolean MapToFocus(GtkWidget* widget, GdkEvent* event, gpointer data) {
-  DOMUIMenuWidget* menu_widget = DOMUIMenuWidget::FindDOMUIMenuWidget(widget);
+  WebUIMenuWidget* menu_widget = WebUIMenuWidget::FindWebUIMenuWidget(widget);
   if (menu_widget) {
     // See EnableInput for the meaning of data.
     bool select_item = data != NULL;
     menu_widget->EnableInput(select_item);
   }
   return true;
 }
 
-void DOMUIMenuWidget::EnableScroll(bool enable) {
+void WebUIMenuWidget::EnableScroll(bool enable) {
   ExecuteJavascript(StringPrintf(
       L"enableScroll(%ls)", enable ? L"true" : L"false"));
 }
 
-void DOMUIMenuWidget::EnableInput(bool select_item) {
+void WebUIMenuWidget::EnableInput(bool select_item) {
   if (!dom_view_)
     return;
   DCHECK(dom_view_->tab_contents()->render_view_host());
   DCHECK(dom_view_->tab_contents()->render_view_host()->view());
   GtkWidget* target =
       dom_view_->tab_contents()->render_view_host()->view()->GetNativeView();
   DCHECK(target);
   // Skip if the widget already own the input.
   if (gtk_grab_get_current() == target)
     return;
@@ skipping 10 matching lines @@
     return;
   }
 
   gtk_grab_add(target);
   dom_view_->tab_contents()->Focus();
   if (select_item) {
     ExecuteJavascript(L"selectItem()");
   }
 }
 
-void DOMUIMenuWidget::ExecuteJavascript(const std::wstring& script) {
-  // Don't exeute there is no DOMView associated. This is fine because
+void WebUIMenuWidget::ExecuteJavascript(const std::wstring& script) {
+  // Don't execute if there is no DOMView associated. This is fine because
   // 1) selectItem make sense only when DOMView is associated.
   // 2) updateModel will be called again when a DOMView is created/assigned.
   if (!dom_view_)
     return;
 
   DCHECK(dom_view_->tab_contents()->render_view_host());
   dom_view_->tab_contents()->render_view_host()->
       ExecuteJavascriptInWebFrame(std::wstring(), script);
 }
 
-void DOMUIMenuWidget::ShowAt(chromeos::MenuLocator* locator) {
+void WebUIMenuWidget::ShowAt(chromeos::MenuLocator* locator) {
   DCHECK(domui_menu_);
   menu_locator_.reset(locator);
   if (!dom_view_) {
     // TODO(oshima): Replace DOMView with direct use of RVH for beta.
     // DOMView should be refactored to use RVH directly, but
     // it'll require a lot of change and will take time.
     dom_view_ = new DOMView();
     dom_view_->Init(domui_menu_->GetProfile(), NULL);
     // TODO(oshima): remove extra view to draw rounded corner.
     views::View* container = new views::View();
     container->AddChildView(dom_view_);
     container->set_border(new RoundedBorder(locator));
     container->SetLayoutManager(new InsetsLayout());
     SetContentsView(container);
     dom_view_->LoadURL(domui_menu_->menu_url());
   } else {
     domui_menu_->UpdateStates();
     dom_view_->GetParent()->set_border(new RoundedBorder(locator));
     menu_locator_->Move(this);
   }
   Show();
 
   // The pointer grab is captured only on the top level menu,
   // all mouse event events are delivered to submenu using gtk_add_grab.
   if (is_root_) {
     CaptureGrab();
   }
 }
 
-void DOMUIMenuWidget::SetSize(const gfx::Size& new_size) {
+void WebUIMenuWidget::SetSize(const gfx::Size& new_size) {
   DCHECK(domui_menu_);
   // Ignore the empty new_size request which is called when
   // menu.html is loaded.
   if (new_size.IsEmpty())
     return;
   int width, height;
   gtk_widget_get_size_request(GetNativeView(), &width, &height);
   gfx::Size real_size(std::max(new_size.width(), width),
                       new_size.height());
   // Ignore the size request with the same size.
   gfx::Rect bounds;
   GetBounds(&bounds, false);
   if (bounds.size() == real_size)
     return;
   menu_locator_->SetBounds(this, real_size);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// DOMUIMenuWidget private:
+// WebUIMenuWidget private:
 
-void DOMUIMenuWidget::CaptureGrab() {
+void WebUIMenuWidget::CaptureGrab() {
   // Release the current grab.
   ClearGrabWidget();
 
   // NOTE: we do this to ensure we get mouse/keyboard events from
   // other apps, a grab done with gtk_grab_add doesn't get events from
   // other apps.
   GdkGrabStatus pointer_grab_status =
       gdk_pointer_grab(window_contents()->window, FALSE,
                        static_cast<GdkEventMask>(
                            GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
                            GDK_POINTER_MOTION_MASK),
                        NULL, NULL, GDK_CURRENT_TIME);
   GdkGrabStatus keyboard_grab_status =
       gdk_keyboard_grab(window_contents()->window, FALSE,
                         GDK_CURRENT_TIME);
 
   did_input_grab_ = pointer_grab_status == GDK_GRAB_SUCCESS &&
       keyboard_grab_status == GDK_GRAB_SUCCESS;
   DCHECK(did_input_grab_);
 
   EnableInput(false /* no selection */);
 }
 
-void DOMUIMenuWidget::ClearGrabWidget() {
+void WebUIMenuWidget::ClearGrabWidget() {
   GtkWidget* grab_widget;
   while ((grab_widget = gtk_grab_get_current()))
     gtk_grab_remove(grab_widget);
 }
 
 }   // namespace chromeos