Aura under Linux

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"
@@ skipping 20 matching lines @@
 #include "views/events/event.h"
 #include "views/ime/input_method.h"
 #include "views/views_delegate.h"
 #include "views/widget/tooltip_manager.h"
 #include "views/widget/widget.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include <gtk/gtk.h>
 #include <gtk/gtkwindow.h>
 #include <gdk/gdkx.h>
+#include "content/browser/renderer_host/gtk_window_utils.h"
+#include "views/widget/native_widget_gtk.h"
 #endif
 
 #if defined(TOUCH_UI)
 #include "chrome/browser/renderer_host/accelerated_surface_container_touch.h"
 #endif
 
+#if defined(OS_POSIX)
+#include "content/browser/renderer_host/gtk_window_utils.h"
+#endif
+
 static const int kMaxWindowWidth = 4000;
 static const int kMaxWindowHeight = 4000;
 static const int kTouchControllerUpdateDelay = 150;
 
 // static
 const char RenderWidgetHostViewViews::kViewClassName[] =
     "browser/renderer_host/RenderWidgetHostViewViews";
 
 using WebKit::WebInputEventFactory;
 using WebKit::WebMouseWheelEvent;
@@ skipping 679 matching lines @@
 
   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)
+#if defined(TOOLKIT_USES_GTK) && !defined(USE_AURA)
     // 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 (GetInnerNativeView()->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)
+#if defined(TOOLKIT_USES_GTK) && !defined(USE_AURA)
     }
 #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();
@@ skipping 90 matching lines @@
   DCHECK(GetInputMethod());
   GetInputMethod()->CancelComposition(this);
   has_composition_text_ = false;
 }
 
 void RenderWidgetHostViewViews::UpdateTouchSelectionController() {
   if (touch_selection_controller_.get())
     touch_selection_controller_->SelectionChanged(selection_start_,
                                                   selection_end_);
 }
+
+#if !defined(OS_WIN)
+void RenderWidgetHostViewViews::UpdateCursor(const WebCursor& cursor) {
+  // 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();
+}
+
+void RenderWidgetHostViewViews::ShowCurrentCursor() {
+#if !defined(USE_AURA)
+  // 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)
+    return;
+#endif
+
+  native_cursor_ = current_cursor_.GetNativeCursor();
+}
+
+gfx::NativeView RenderWidgetHostViewViews::GetInnerNativeView() const {
+#if defined(USE_AURA)
+  return NULL;
+#else
+  const views::View* view = NULL;
+  if (views::ViewsDelegate::views_delegate)
+    view = views::ViewsDelegate::views_delegate->GetDefaultParentView();
+  if (!view)
+    view = this;
+
+  // TODO(sad): Ideally this function should be equivalent to GetNativeView, and
+  // NativeWidgetGtk-specific function call should not be necessary.
+  const views::Widget* widget = view->GetWidget();
+  const views::NativeWidget* native = widget ? widget->native_widget() : NULL;
+  return native ? static_cast<const views::NativeWidgetGtk*>(native)->
+      window_contents() : NULL;
+#endif
+}
+#endif  // !OS_WIN
+
+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);
+}
+
+void RenderWidgetHostViewViews::AcceleratedCompositingActivated(
+    bool activated) {
+  // TODO(anicolao): figure out if we need something here
+  if (activated)
+    NOTIMPLEMENTED();
+}
+
+#if defined(OS_POSIX)
+void RenderWidgetHostViewViews::GetDefaultScreenInfo(
+    WebKit::WebScreenInfo* results) {
+  NOTIMPLEMENTED();
+}
+
+void RenderWidgetHostViewViews::GetScreenInfo(WebKit::WebScreenInfo* results) {
+#if !defined(USE_AURA)
+  views::Widget* widget = GetWidget() ? GetWidget()->GetTopLevelWidget() : NULL;
+  if (widget)
+    content::GetScreenInfoFromNativeWindow(widget->GetNativeView()->window,
+                                           results);
+#endif
+}
+
+gfx::Rect RenderWidgetHostViewViews::GetRootWindowBounds() {
+  views::Widget* widget = GetWidget() ? GetWidget()->GetTopLevelWidget() : NULL;
+  return widget ? widget->GetWindowScreenBounds() : gfx::Rect();
+}
+#endif
+
+#if !defined(TOUCH_UI)
+gfx::PluginWindowHandle RenderWidgetHostViewViews::GetCompositingSurface() {
+  // TODO(oshima): The original implementation was broken as
+  // GtkNativeViewManager doesn't know about NativeWidgetGtk. Figure
+  // out if this makes sense without compositor. If it does, then find
+  // out the right way to handle.
+  NOTIMPLEMENTED();
+  return gfx::kNullPluginWindow;
+}
+#endif
+
+#if defined(USE_AURA)
+// static
+RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
+    RenderWidgetHost* widget) {
+  return new RenderWidgetHostViewViews(widget);
+}
+#endif