Replace TabContentsViewGtk with TabContentsViewViews as part of the ongoing

chrome/browser/renderer_host/render_widget_host_view_views.cc

 // Copyright (c) 2010 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 "app/keyboard_code_conversion_gtk.h"
 #include "app/l10n_util.h"
 #include "app/x11_util.h"
 #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/browser/renderer_host/backing_store_x.h"
 #include "chrome/browser/renderer_host/gpu_view_host.h"
 #include "chrome/browser/renderer_host/render_widget_host.h"
 #include "chrome/browser/renderer_host/video_layer_x.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/native_web_keyboard_event.h"
 #include "chrome/common/render_messages.h"
+#include "gfx/canvas.h"
 #include "third_party/WebKit/WebKit/chromium/public/gtk/WebInputEventFactory.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h"
 #include "views/event.h"
 #include "views/widget/widget.h"
 
 static const int kMaxWindowWidth = 4000;
 static const int kMaxWindowHeight = 4000;
 static const char* kRenderWidgetHostViewKey = "__RENDER_WIDGET_HOST_VIEW__";
 
 using WebKit::WebInputEventFactory;
@@ skipping 87 matching lines @@
   GetRenderWidgetHost()->WasHidden();
 }
 
 void RenderWidgetHostViewViews::SetSize(const gfx::Size& size) {
   // This is called when webkit has sent us a Move message.
   int width = std::min(size.width(), kMaxWindowWidth);
   int height = std::min(size.height(), kMaxWindowHeight);
   if (requested_size_.width() != width ||
       requested_size_.height() != height) {
     requested_size_ = gfx::Size(width, height);
-    SetBounds(GetViewBounds());
+    SetBounds(gfx::Rect(x(), y(), width, height));
     host_->WasResized();
   }
 }
 
 void RenderWidgetHostViewViews::MovePluginWindows(
     const std::vector<webkit_glue::WebPluginGeometry>& moves) {
   // TODO(anicolao): NIY
   NOTIMPLEMENTED();
 }
 
@@ skipping 134 matching lines @@
     }
     return gpu_view_host_->CreateBackingStore(size);
   }
 
   return new BackingStoreX(host_, size,
                            x11_util::GetVisualFromGtkWidget(native_view()),
                            gtk_widget_get_visual(native_view())->depth);
 }
 
 gfx::NativeView RenderWidgetHostViewViews::native_view() const {
-  return GetWidget()->GetNativeView();
+  if (GetWidget())
+    return GetWidget()->GetNativeView();
+  return NULL;
 }
 
 VideoLayer* RenderWidgetHostViewViews::AllocVideoLayer(const gfx::Size& size) {
   if (enable_gpu_rendering_) {
     // TODO(scherkus): is it possible for a video layer to be allocated before a
     // backing store?
     DCHECK(gpu_view_host_.get())
         << "AllocVideoLayer() called before AllocBackingStore()";
     return gpu_view_host_->CreateVideoLayer(size);
   }
 
   return new VideoLayerX(host_, size,
                          x11_util::GetVisualFromGtkWidget(native_view()),
                          gtk_widget_get_visual(native_view())->depth);
 }
 
 void RenderWidgetHostViewViews::SetBackground(const SkBitmap& background) {
   RenderWidgetHostView::SetBackground(background);
   host_->Send(new ViewMsg_SetBackground(host_->routing_id(), background));
 }
 
 void RenderWidgetHostViewViews::Paint(gfx::Canvas* canvas) {
+  if (is_hidden_) {
+    return;
+  }
+
+  // Paint a "hole" in the canvas so that the render of the web page is on
+  // top of whatever else has already been painted in the views hierarchy.
+  // Later views might still get to paint on top.
+  canvas->FillRectInt(SK_ColorBLACK, 0, 0, kMaxWindowWidth, kMaxWindowHeight,
+                      SkXfermode::kClear_Mode);
+
   if (enable_gpu_rendering_) {
     // When we're proxying painting, we don't actually display the web page
     // ourselves.
     if (gpu_view_host_.get())
       gpu_view_host_->OnWindowPainted();
 
     // Erase the background. This will prevent a flash of black when resizing
     // or exposing the window. White is usually better than black.
     return;
   }
 
   // Don't do any painting if the GPU process is rendering directly
   // into the View.
   RenderWidgetHost* render_widget_host = GetRenderWidgetHost();
   if (render_widget_host->is_gpu_rendering_active()) {
     return;
   }
 
   GdkWindow* window = native_view()->window;
   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;
   BackingStoreX* backing_store = static_cast<BackingStoreX*>(
       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) {
     // 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) {
       if (!visually_deemphasized_) {
         // In the common case, use XCopyArea. We don't draw more than once, so
         // we don't need to double buffer.
-        backing_store->XShowRect(
+        backing_store->XShowRect(origin,
             paint_rect, x11_util::GetX11WindowFromGtkWidget(native_view()));
 
         // Paint the video layer using XCopyArea.
         // TODO(scherkus): implement VideoLayerX::CairoShow() for grey
         // blending.
         VideoLayerX* video_layer = static_cast<VideoLayerX*>(
             host_->video_layer());
         if (video_layer)
           video_layer->XShow(
               x11_util::GetX11WindowFromGtkWidget(native_view()));
@@ skipping 159 matching lines @@
   }
 #endif
 
   ShowCurrentCursor();
   GetRenderWidgetHost()->GotFocus();
 }
 
 void RenderWidgetHostViewViews::WillLoseFocus() {
   // If we are showing a context menu, maintain the illusion that webkit has
   // focus.
-  if (!is_showing_context_menu_)
+  if (!is_showing_context_menu_ && !is_hidden_)
     GetRenderWidgetHost()->Blur();
 }
 
 
 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 (!native_view()->window)
+  if (!native_view() || !native_view()->window)
     return;
 
   // TODO(anicolao): change to set cursors without GTK
 }
 
 void RenderWidgetHostViewViews::CreatePluginContainer(
     gfx::PluginWindowHandle id) {
   // TODO(anicolao): plugin_container_manager_.CreatePluginContainer(id);
 }
 
@@ skipping 62 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);
 }