gfx::Compositor: SchedulePaint.

ui/gfx/compositor/compositor_win.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 "ui/gfx/compositor/compositor.h"
 
 #include <algorithm>
 #include <d3dx10.h>
 #include <vector>
 
@@ skipping 68 matching lines @@
   ScopedComPtr<ID3D10Texture2D> texture_;
   ScopedComPtr<ID3D10ShaderResourceView> shader_view_;
   ScopedComPtr<ID3D10Buffer> vertex_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewTexture);
 };
 
 // D3D 10 Compositor implementation.
 class CompositorWin : public Compositor {
  public:
-  CompositorWin(gfx::AcceleratedWidget widget,
+  CompositorWin(CompositorDelegate* delegate,
+                gfx::AcceleratedWidget widget,
                 const gfx::Size& size);
 
   void Init();
 
   // Invoked to update the perspective needed by this texture. |transform| is
   // the transform for the texture, and |size| the size of the texture.
   void UpdatePerspective(const ui::Transform& transform,
                          const gfx::Size& view_size);
 
   // Returns the index buffer used for drawing a texture.
@@ skipping 214 matching lines @@
   buffer_desc.ByteWidth = sizeof(Vertex) * ARRAYSIZE_UNSAFE(vertices);
   buffer_desc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
   buffer_desc.CPUAccessFlags = 0;
   buffer_desc.MiscFlags = 0;
   D3D10_SUBRESOURCE_DATA init_data;
   init_data.pSysMem = vertices;
   RETURN_IF_FAILED(device_->CreateBuffer(&buffer_desc, &init_data,
                                          vertex_buffer_.Receive()));
 }
 
-CompositorWin::CompositorWin(gfx::AcceleratedWidget widget,
+CompositorWin::CompositorWin(CompositorDelegate* delegate,
+                             gfx::AcceleratedWidget widget,
                              const gfx::Size& size)
-    : Compositor(size),
+    : Compositor(delegate, size),
       host_(widget),
       technique_(NULL) {
 }
 
 void CompositorWin::Init() {
   CreateDevice();
   LoadEffects();
   OnWidgetSizeChanged();
   InitVertexLayout();
   CreateVertexBuffer();
@@ skipping 156 matching lines @@
   // A warning is generated if a bound vertexbuffer is deleted. To avoid that
   // warning we reset the buffer here. We only do it for debug builds as it's
   // ok to effectively unbind the vertex buffer.
   vertex_buffer = vertex_buffer_.get();
   device_->IASetVertexBuffers(0, 1, &vertex_buffer, &stride, &offset);
   device_->IASetIndexBuffer(index_buffer_.get(), DXGI_FORMAT_R32_UINT, 0);
 #endif
 }
 
 void CompositorWin::SchedulePaint() {
-  RECT bounds;
-  GetClientRect(host_, &bounds);
-  InvalidateRect(host_, &bounds, FALSE);
+  delegate()->ScheduleCompositorPaint();

[sky, 2011/09/06 20:12:36]

Both implementations are the same. Promote it to Compositor.

[sadrul, 2011/09/06 21:50:11]

Done. (I added the implementation in compositor.h since compositor.cc is not
compiled with compositor_gl/_win, and Compositor::WidgetSizeChanged is also
defined in compositor.h)

 }
 
 void CompositorWin::OnWidgetSizeChanged() {
   dest_render_target_view_ = NULL;
   depth_stencil_buffer_ = NULL;
   depth_stencil_view_ = NULL;
 
   main_render_target_view_ = NULL;
   main_texture_ = NULL;
   main_texture_shader_view_ = NULL;
@@ skipping 273 matching lines @@
   if (error_code != S_OK) {
     Errored(error_code);
     return NULL;
   }
   return vertex_buffer;
 }
 
 }  // namespace
 
 // static
-Compositor* Compositor::Create(gfx::AcceleratedWidget widget,
+Compositor* Compositor::Create(CompositorDelegate* delegate,
+                               gfx::AcceleratedWidget widget,
                                const gfx::Size& size) {
-  CompositorWin* compositor = new CompositorWin(widget, size);
+  CompositorWin* compositor = new CompositorWin(delegate, widget, size);
   compositor->Init();
   return compositor;
 }
 
 }  // namespace ui