Vend common GL context

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 79 matching lines @@
   CompositorWin(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 overall size of the compositor.
-  const gfx::Size& GetHostSize();
-
   // Returns the index buffer used for drawing a texture.
   ID3D10Buffer* GetTextureIndexBuffer();
 
   // Compositor:
   virtual Texture* CreateTexture() OVERRIDE;
   virtual void NotifyStart() OVERRIDE;
   virtual void NotifyEnd() OVERRIDE;
   virtual void Blur(const gfx::Rect& bounds) OVERRIDE;
   virtual void SchedulePaint() OVERRIDE;
   virtual void OnWidgetSizeChanged(const gfx::Size& size) OVERRIDE;
@@ skipping 185 matching lines @@
           (SkColorGetA(color) << 24) |
           (SkColorGetB(color) << 16) |
           (SkColorGetG(color) << 8) |
           (SkColorGetR(color));
     }
   }
 }
 
 void ViewTexture::CreateVertexBuffer(const gfx::Size& size) {
   vertex_buffer_.Release();
-  const gfx::Size& host_size = compositor_->GetHostSize();
+  const gfx::Size& host_size = compositor_->size();
   float x = static_cast<float>(host_size.width()) / 2.0f;
   float y = static_cast<float>(host_size.height()) / 2.0f;
   float w = static_cast<float>(size.width());
   float h = static_cast<float>(size.height());
   Vertex vertices[] = {
     { D3DXVECTOR3(0.0f,   -h, 0.0f), D3DXVECTOR2(0.0f, 1.0f) },
     { D3DXVECTOR3(0.0f, 0.0f, 0.0f), D3DXVECTOR2(0.0f, 0.0f) },
     { D3DXVECTOR3(   w, 0.0f, 0.0f), D3DXVECTOR2(1.0f, 0.0f) },
     { D3DXVECTOR3(   w,   -h, 0.0f), D3DXVECTOR2(1.0f, 1.0f) },
   };
 
   // Create the vertex buffer containing the points.
   D3D10_BUFFER_DESC buffer_desc;
   buffer_desc.Usage = D3D10_USAGE_IMMUTABLE;
   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,
                              const gfx::Size& size)
-    : host_(widget),
-      technique_(NULL),
-      last_size_(size) {
+    : Compositor(size),
+      host_(widget),
+      technique_(NULL) {
 }
 
 void CompositorWin::Init() {
   CreateDevice();
   LoadEffects();
-  Resize(last_size_);
+  Resize(size());
   InitVertexLayout();
   CreateVertexBuffer();
   CreateIndexBuffer();
 }
 
 void CompositorWin::UpdatePerspective(const ui::Transform& transform,
                                       const gfx::Size& view_size) {
   float transform_data_buffer[16];
   transform.matrix().asColMajorf(transform_data_buffer);
   D3DXMATRIX transform_matrix(&transform_data_buffer[0]);
@@ skipping 26 matching lines @@
   D3DXMATRIX view;
   D3DXMatrixIdentity(&view);
   D3DXMatrixLookAtLH(&view, &pos, &target, &up);
 
   D3DXMATRIX wvp = transform_matrix * scale_matrix * translate_matrix * view *
       projection_matrix;
 
   fx_->GetVariableByName("gWVP")->AsMatrix()->SetMatrix(wvp);
 }
 
-const gfx::Size& CompositorWin::GetHostSize() {
-  return last_size_;

[sky, 2011/08/24 21:17:08]

I don't think you wired up changing the size correctly for this class.

[jonathan.backer, 2011/08/25 18:57:18]

Done.

-}
-
 ID3D10Buffer* CompositorWin::GetTextureIndexBuffer() {
   return index_buffer_.get();
 }
 
 Texture* CompositorWin::CreateTexture() {
   return new ViewTexture(this, device_.get(), fx_.get());
 }
 
 void CompositorWin::NotifyStart() {
   ID3D10RenderTargetView* target_view = main_render_target_view_.get();
@@ skipping 412 matching lines @@
 
 // static
 Compositor* Compositor::Create(gfx::AcceleratedWidget widget,
                                const gfx::Size& size) {
   CompositorWin* compositor = new CompositorWin(widget, size);
   compositor->Init();
   return compositor;
 }
 
 }  // namespace ui