Add an option to run Chrome in the views desktop.

chrome/browser/renderer_host/render_widget_host_view_views.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_views.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/task.h"
 #include "base/time.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/renderer_host/backing_store_skia.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/common/native_web_keyboard_event.h"
 #include "content/common/result_codes.h"
 #include "content/common/view_messages.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/gtk/WebInputEventFactory.h"
-#include "ui/base/keycodes/keyboard_code_conversion_gtk.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/base/x/x11_util.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/canvas_skia.h"
-#include "ui/gfx/gtk_native_view_id_manager.h"
 #include "views/events/event.h"
 #include "views/ime/input_method.h"
+#include "views/widget/widget.h"
+
+#if defined(TOOLKIT_USES_GTK)
+#include "ui/base/keycodes/keyboard_code_conversion_gtk.h"
+#include "ui/base/x/x11_util.h"
+#include "ui/gfx/gtk_native_view_id_manager.h"
 #include "views/widget/native_widget_gtk.h"
-#include "views/widget/widget.h"
+#endif
 
 static const int kMaxWindowWidth = 4000;
 static const int kMaxWindowHeight = 4000;
 static const char kRenderWidgetHostViewKey[] = "__RENDER_WIDGET_HOST_VIEW__";
 
 // Copied from third_party/WebKit/Source/WebCore/page/EventHandler.cpp
 //
 // Match key code of composition keydown event on windows.
 // IE sends VK_PROCESSKEY which has value 229;
 //
@@ skipping 23 matching lines @@
   if (event.IsControlDown())
     modifiers |= WebKit::WebInputEvent::ControlKey;
   if (event.IsAltDown())
     modifiers |= WebKit::WebInputEvent::AltKey;
   if (event.IsCapsLockDown())
     modifiers |= WebKit::WebInputEvent::CapsLockOn;
 
   return modifiers;
 }
 
+#if defined(TOUCH_UI)

[sky, 2011/06/21 21:52:11]

oi, ifdef heaven. Any chance of making this code a little easier to read?

 WebKit::WebTouchPoint::State TouchPointStateFromEvent(
     const views::TouchEvent* event) {
   switch (event->type()) {
     case ui::ET_TOUCH_PRESSED:
       return WebKit::WebTouchPoint::StatePressed;
     case ui::ET_TOUCH_RELEASED:
       return WebKit::WebTouchPoint::StateReleased;
     case ui::ET_TOUCH_MOVED:
       return WebKit::WebTouchPoint::StateMoved;
     case ui::ET_TOUCH_CANCELLED:
@@ skipping 29 matching lines @@
 
 void UpdateTouchPointPosition(const views::TouchEvent* event,
                               const gfx::Point& origin,
                               WebKit::WebTouchPoint* tpoint) {
   tpoint->position.x = event->x();
   tpoint->position.y = event->y();
 
   tpoint->screenPosition.x = tpoint->position.x + origin.x();
   tpoint->screenPosition.y = tpoint->position.y + origin.y();
 }
+#endif  // TOUCH_UI
 
 void InitializeWebMouseEventFromViewsEvent(const views::LocatedEvent& event,
                                            const gfx::Point& origin,
                                            WebKit::WebMouseEvent* wmevent) {
   wmevent->timeStampSeconds = base::Time::Now().ToDoubleT();
   wmevent->modifiers = WebInputEventFlagsFromViewsEvent(event);
 
   wmevent->windowX = wmevent->x = event.x();
   wmevent->windowY = wmevent->y = event.y();
   wmevent->globalX = wmevent->x + origin.x();
   wmevent->globalY = wmevent->y + origin.y();
 }
 
 }  // namespace
 
+#if defined(TOUCH_UI)
 // static
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewViews(widget);
 }
+#endif  // TOUCH_UI
 
 RenderWidgetHostViewViews::RenderWidgetHostViewViews(RenderWidgetHost* host)
     : host_(host),
       about_to_validate_and_paint_(false),
       is_hidden_(false),
       is_loading_(false),
       native_cursor_(NULL),
       is_showing_popup_menu_(false),
       visually_deemphasized_(false),
       touch_event_(),
@@ skipping 113 matching lines @@
 
 bool RenderWidgetHostViewViews::IsShowing() {
   return IsVisible();
 }
 
 gfx::Rect RenderWidgetHostViewViews::GetViewBounds() const {
   return bounds();
 }
 
 void RenderWidgetHostViewViews::UpdateCursor(const WebCursor& cursor) {
+#if defined(TOOLKIT_USES_GTK)
   // Optimize the common case, where the cursor hasn't changed.
   // However, we can switch between different pixmaps, so only on the
   // non-pixmap branch.
   if (current_cursor_.GetCursorType() != GDK_CURSOR_IS_PIXMAP &&
       current_cursor_.GetCursorType() == cursor.GetCursorType()) {
     return;
   }
 
   current_cursor_ = cursor;
   ShowCurrentCursor();
+#endif  // TOOLKIT_USES_GTK
 }
 
 void RenderWidgetHostViewViews::SetIsLoading(bool is_loading) {
   is_loading_ = is_loading;
+#if defined(TOOLKIT_USES_GTK)
   // Only call ShowCurrentCursor() when it will actually change the cursor.
   if (current_cursor_.GetCursorType() == GDK_LAST_CURSOR)
     ShowCurrentCursor();
+#endif  // TOOLKIT_USES_GTK
 }
 
 void RenderWidgetHostViewViews::ImeUpdateTextInputState(
     ui::TextInputType type,
     bool can_compose_inline,
     const gfx::Rect& caret_rect) {
   // TODO(kinaba): currently, can_compose_inline is ignored and always treated
   // as true. We need to support "can_compose_inline=false" for PPAPI plugins
   // that may want to avoid drawing composition-text by themselves and pass
   // the responsibility to the browser.
@@ skipping 90 matching lines @@
 
   return new BackingStoreSkia(host_, size);
 }
 
 void RenderWidgetHostViewViews::SetBackground(const SkBitmap& background) {
   RenderWidgetHostView::SetBackground(background);
   if (host_)
     host_->Send(new ViewMsg_SetBackground(host_->routing_id(), background));
 }
 
+#if defined(TOOLKIT_USES_GTK)
 void RenderWidgetHostViewViews::CreatePluginContainer(
     gfx::PluginWindowHandle id) {
   // TODO(anicolao): plugin_container_manager_.CreatePluginContainer(id);
 }
 
 void RenderWidgetHostViewViews::DestroyPluginContainer(
     gfx::PluginWindowHandle id) {
   // TODO(anicolao): plugin_container_manager_.DestroyPluginContainer(id);
 }
+#endif  // TOOLKIT_USES_GTK
 
 void RenderWidgetHostViewViews::SetVisuallyDeemphasized(
     const SkColor* color, bool animate) {
   // TODO(anicolao)
 }
 
 bool RenderWidgetHostViewViews::ContainsNativeView(
     gfx::NativeView native_view) const {
   // TODO(port)
   NOTREACHED() <<
-    "RenderWidgetHostViewViews::ContainsNativeView not implemented.";
+      "RenderWidgetHostViewViews::ContainsNativeView not implemented.";
   return false;
 }
 
+#if defined(TOOLKIT_USES_GTK)
 void RenderWidgetHostViewViews::AcceleratedCompositingActivated(
     bool activated) {
   // TODO(anicolao): figure out if we need something here
   if (activated)
     NOTIMPLEMENTED();
 }
+#endif  // TOOLKIT_USES_GTK
+
+#if defined(OS_WIN)
+void RenderWidgetHostViewViews::WillWmDestroy() {
+  NOTIMPLEMENTED();
+}
+
+void RenderWidgetHostViewViews::ShowCompositorHostWindow(bool show) {
+  NOTIMPLEMENTED();
+}
+#endif  // OS_WIN
 
 gfx::PluginWindowHandle RenderWidgetHostViewViews::GetCompositingSurface() {
+#if defined(TOOLKIT_USES_GTK)
   GtkNativeViewManager* manager = GtkNativeViewManager::GetInstance();
   gfx::PluginWindowHandle surface = gfx::kNullPluginWindow;
   gfx::NativeViewId view_id = gfx::IdFromNativeView(GetInnerNativeView());
 
   if (!manager->GetXIDForId(&surface, view_id)) {
     DLOG(ERROR) << "Can't find XID for view id " << view_id;
   }
   return surface;
+#else  // TOOLKIT_USES_GTK
+  return NULL;
+#endif
 }
 
 gfx::NativeView RenderWidgetHostViewViews::GetInnerNativeView() const {
+#if defined(TOOLKIT_USES_GTK)
   // TODO(sad): Ideally this function should be equivalent to GetNativeView, and
   // NativeWidgetGtk-specific function call should not be necessary.
   const views::Widget* widget = GetWidget();
   const views::NativeWidget* native = widget ? widget->native_widget() : NULL;
   return native ? static_cast<const views::NativeWidgetGtk*>(native)->
       window_contents() : NULL;
+#else  // TOOLKIT_USES_GTK
+  // TODO(beng): Figure out what to do here for Windows/v.o.v.
+  return NULL;
+#endif
 }
 
 std::string RenderWidgetHostViewViews::GetClassName() const {
   return kViewClassName;
 }
 
 gfx::NativeCursor RenderWidgetHostViewViews::GetCursor(
     const views::MouseEvent& event) {
   return native_cursor_;
 }
@@ skipping 45 matching lines @@
 }
 
 void RenderWidgetHostViewViews::OnMouseEntered(const views::MouseEvent& event) {
   // Already generated synthetically by webkit.
 }
 
 void RenderWidgetHostViewViews::OnMouseExited(const views::MouseEvent& event) {
   // Already generated synthetically by webkit.
 }
 
+#if defined(TOUCH_UI)
 ui::TouchStatus RenderWidgetHostViewViews::OnTouchEvent(
     const views::TouchEvent& event) {
   if (!host_)
     return ui::TOUCH_STATUS_UNKNOWN;
 
   // Update the list of touch points first.
   WebKit::WebTouchPoint* point = NULL;
   ui::TouchStatus status = ui::TOUCH_STATUS_UNKNOWN;
 
   switch (event.type()) {
@@ skipping 83 matching lines @@
       touch_event_.touchPoints[i] = touch_event_.touchPoints[i + 1];
     }
     if (touch_event_.touchPointsLength == 0)
       status = ui::TOUCH_STATUS_END;
   } else if (event.type() == ui::ET_TOUCH_CANCELLED) {
     status = ui::TOUCH_STATUS_CANCEL;
   }
 
   return status;
 }
+#endif  // TOUCH_UI
 
 bool RenderWidgetHostViewViews::OnKeyPressed(const views::KeyEvent& event) {
   // TODO(suzhe): Support editor key bindings.
   if (!host_)
     return false;
   host_->ForwardKeyboardEvent(NativeWebKeyboardEvent(event));
   return true;
 }
 
 bool RenderWidgetHostViewViews::OnKeyReleased(const views::KeyEvent& event) {
@@ skipping 167 matching lines @@
   // Later views might still get to paint on top.
   canvas->FillRectInt(SK_ColorBLACK, 0, 0,
                       bounds().width(), bounds().height(),
                       SkXfermode::kClear_Mode);
 
   // Don't do any painting if the GPU process is rendering directly
   // into the View.
   if (host_->is_accelerated_compositing_active())
     return;
 
+#if defined(TOOLKIT_USES_GTK)
   GdkWindow* window = GetInnerNativeView()->window;
+#endif
   DCHECK(!about_to_validate_and_paint_);
 
   // TODO(anicolao): get the damage somehow
   // invalid_rect_ = damage_rect;
   invalid_rect_ = bounds();
   gfx::Point origin;
   ConvertPointToWidget(this, &origin);
 
   about_to_validate_and_paint_ = true;
   BackingStore* backing_store = host_->GetBackingStore(true);
   // Calling GetBackingStore maybe have changed |invalid_rect_|...
   about_to_validate_and_paint_ = false;
 
   gfx::Rect paint_rect = gfx::Rect(0, 0, kMaxWindowWidth, kMaxWindowHeight);
   paint_rect = paint_rect.Intersect(invalid_rect_);
 
   if (backing_store) {
+#if defined(TOOLKIT_USES_GTK)
     // Only render the widget if it is attached to a window; there's a short
     // period where this object isn't attached to a window but hasn't been
     // Destroy()ed yet and it receives paint messages...
     if (window) {
+#endif
       if (!visually_deemphasized_) {
         // In the common case, use XCopyArea. We don't draw more than once, so
         // we don't need to double buffer.
         if (IsPopup()) {
           origin.SetPoint(origin.x() + paint_rect.x(),
                           origin.y() + paint_rect.y());
           paint_rect.SetRect(0, 0, paint_rect.width(), paint_rect.height());
         }
         static_cast<BackingStoreSkia*>(backing_store)->SkiaShowRect(
             gfx::Point(paint_rect.x(), paint_rect.y()), canvas);
       } else {
         // TODO(sad)
         NOTIMPLEMENTED();
       }
+#if defined(TOOLKIT_USES_GTK)
     }
+#endif
     if (!whiteout_start_time_.is_null()) {
       base::TimeDelta whiteout_duration = base::TimeTicks::Now() -
           whiteout_start_time_;
       UMA_HISTOGRAM_TIMES("MPArch.RWHH_WhiteoutDuration", whiteout_duration);
 
       // Reset the start time to 0 so that we start recording again the next
       // time the backing store is NULL...
       whiteout_start_time_ = base::TimeTicks();
     }
     if (!tab_switch_paint_time_.is_null()) {
@@ skipping 48 matching lines @@
   return popup_type_ == WebKit::WebPopupTypeSelect;
 }
 
 bool RenderWidgetHostViewViews::IsPopup() {
   return popup_type_ != WebKit::WebPopupTypeNone;
 }
 
 void RenderWidgetHostViewViews::ShowCurrentCursor() {
   // The widget may not have a window. If that's the case, abort mission. This
   // is the same issue as that explained above in Paint().
-  if (!GetInnerNativeView() || !GetInnerNativeView()->window)
+  if (!GetInnerNativeView()
+#if defined(TOOLKIT_USES_GTK)
+        || !GetInnerNativeView()->window)
+#else
+    )
+#endif
     return;
 
   native_cursor_ = current_cursor_.GetNativeCursor();
 }
 
 WebKit::WebMouseEvent RenderWidgetHostViewViews::WebMouseEventFromViewsEvent(
     const views::MouseEvent& event) {
   WebKit::WebMouseEvent wmevent;
   InitializeWebMouseEventFromViewsEvent(event, GetMirroredPosition(), &wmevent);
 
@@ skipping 18 matching lines @@
 void RenderWidgetHostViewViews::FinishImeCompositionSession() {
   if (!has_composition_text_)
     return;
   if (host_)
     host_->ImeConfirmComposition();
   DCHECK(GetInputMethod());
   GetInputMethod()->CancelComposition(this);
   has_composition_text_ = false;
 }
 
+#if defined(TOUCH_UI)
 // static
 RenderWidgetHostView*
     RenderWidgetHostView::GetRenderWidgetHostViewFromNativeView(
         gfx::NativeView widget) {
+  // TODO(beng): Figure out what to do here for Windows/v.o.v.
   gpointer user_data = g_object_get_data(G_OBJECT(widget),
                                          kRenderWidgetHostViewKey);
   return reinterpret_cast<RenderWidgetHostView*>(user_data);
 }
+#endif  // TOUCH_UI