[ui/surface] Separate image processing logic from presentation logic.

The D3D image processing code from AcceleratedPresenter moves to its own class, "ui/surface/accelerated_surface_transformer_win.h". This split allows the image processing code to be tested independently of the present-scheduling system, and so we add unit tests doing exactly that. Utility functions (loading d3d, creating temp surfaces) doing things commonly required by test, transform, and present code -- these functions are moved to a third location, "ui/surface/d3d9_utils_win.h"

The new unit tests -- which live in the ui_unittests binary -- make extensive use of pseudorandom image content, which I think is kind of neat. The tests use D3D HAL devices; I tried to use REF, but it didn't work, as StretchRect+LINEAR is not supported by refrast. So as a result we may have a GPU vendor dependency in these results.

BUG=161537
TEST=new ui_unittests

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=174028

Review URL: https://chromiumcodereview.appspot.com/11464017

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@174338 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 1006 insertions, 240 deletions

diff --git a/ui/surface/accelerated_surface_transformer_win.cc b/ui/surface/accelerated_surface_transformer_win.cc
new file mode 100644
index 0000000..1c57ae1
--- /dev/null
+++ b/ui/surface/accelerated_surface_transformer_win.cc
@@ -0,0 +1,261 @@
+// Copyright (c) 2012 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/surface/accelerated_surface_transformer_win.h"
+
+#include <vector>
+
+#include "accelerated_surface_transformer_win_hlsl_compiled.h"
+#include "base/debug/trace_event.h"
+#include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
+#include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/win/scoped_comptr.h"
+#include "ui/gfx/native_widget_types.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/size.h"
+#include "ui/surface/d3d9_utils_win.h"
+#include "ui/surface/surface_export.h"
+
+using base::win::ScopedComPtr;
+using std::vector;
+
+namespace d3d_utils = ui_surface_d3d9_utils;
+
+namespace {
+
+struct Vertex {
+  float x, y, z, w;
+  float u, v;
+};
+
+const static D3DVERTEXELEMENT9 g_vertexElements[] = {
+  { 0, 0, D3DDECLTYPE_FLOAT4, 0, D3DDECLUSAGE_POSITION, 0 },
+  { 0, 16, D3DDECLTYPE_FLOAT2, 0, D3DDECLUSAGE_TEXCOORD, 0 },
+  D3DDECL_END()
+};
+
+// Calculate the number necessary to transform |src_subrect| into |dst_size|
+// by repeating downsampling of the image of |src_subrect| by a factor no more
+// than 2.
+int GetResampleCount(const gfx::Rect& src_subrect,
+                     const gfx::Size& dst_size,
+                     const gfx::Size& back_buffer_size) {
+  // At least one copy is required, since the back buffer itself is not
+  // lockable.
+  int min_resample_count = 1;
+  int width_count = 0;
+  int width = src_subrect.width();
+  while (width > dst_size.width()) {
+    ++width_count;
+    width >>= 1;
+  }
+  int height_count = 0;
+  int height = src_subrect.height();
+  while (height > dst_size.height()) {
+    ++height_count;
+    height >>= 1;
+  }
+  return std::max(std::max(width_count, height_count),
+                  min_resample_count);
+}
+
+// Returns half the size of |size| no smaller than |min_size|.
+gfx::Size GetHalfSizeNoLessThan(const gfx::Size& size,
+                                const gfx::Size& min_size) {
+  return gfx::Size(std::max(min_size.width(), size.width() / 2),
+                   std::max(min_size.height(), size.height() / 2));
+}
+
+gfx::Size GetSize(IDirect3DSurface9* surface) {
+  D3DSURFACE_DESC surface_description;
+  HRESULT hr = surface->GetDesc(&surface_description);
+  if (FAILED(hr))
+    return gfx::Size(0, 0);
+  return gfx::Size(surface_description.Width, surface_description.Height);
+}
+
+}  // namespace
+
+
+AcceleratedSurfaceTransformer::AcceleratedSurfaceTransformer() {}
+
+bool AcceleratedSurfaceTransformer::Init(IDirect3DDevice9* device) {
+  device_ = device;
+  if (!InitShaderCombo(
+          ui_surface::AcceleratedSurfaceTransformerWinHLSL::kVsOneTexture,
+          ui_surface::AcceleratedSurfaceTransformerWinHLSL::kPsOneTexture,
+          SIMPLE_TEXTURE)) {
+    ReleaseAll();
+    return false;
+  }
+
+  base::win::ScopedComPtr<IDirect3DVertexDeclaration9> vertex_declaration;
+  HRESULT hr = device_->CreateVertexDeclaration(g_vertexElements,
+                                                vertex_declaration.Receive());
+  if (!SUCCEEDED(hr)) {
+    ReleaseAll();
+    return false;
+  }
+  device_->SetVertexDeclaration(vertex_declaration);
+
+  return true;
+}
+
+bool AcceleratedSurfaceTransformer::InitShaderCombo(
+    const BYTE vertex_shader_instructions[],
+    const BYTE pixel_shader_instructions[],
+    ShaderCombo shader_combo_name) {
+  HRESULT hr = device_->CreateVertexShader(
+      reinterpret_cast<const DWORD*>(vertex_shader_instructions),
+      vertex_shaders_[shader_combo_name].Receive());
+
+  if (FAILED(hr))
+    return false;
+
+  hr = device_->CreatePixelShader(
+      reinterpret_cast<const DWORD*>(pixel_shader_instructions),
+      pixel_shaders_[shader_combo_name].Receive());
+
+  return SUCCEEDED(hr);
+}
+
+
+void AcceleratedSurfaceTransformer::ReleaseAll() {
+  for (int i = 0; i < NUM_SHADERS; i++) {
+    vertex_shaders_[i] = NULL;
+    vertex_shaders_[i] = NULL;
+  }
+  device_ = NULL;
+}
+void AcceleratedSurfaceTransformer::DetachAll() {
+  for (int i = 0; i < NUM_SHADERS; i++) {
+    vertex_shaders_[i].Detach();
+    vertex_shaders_[i].Detach();
+  }
+  device_.Detach();
+}
+
+// Draw a textured quad to a surface.
+bool AcceleratedSurfaceTransformer::CopyInverted(
+    IDirect3DTexture9* src_texture,
+    IDirect3DSurface9* dst_surface,
+    const gfx::Size& dst_size) {
+  base::win::ScopedComPtr<IDirect3DSurface9> default_color_target;
+  device()->GetRenderTarget(0, default_color_target.Receive());
+
+  if (!SetShaderCombo(SIMPLE_TEXTURE))
+    return false;
+
+  device()->SetRenderTarget(0, dst_surface);
+  device()->SetTexture(0, src_texture);
+
+  D3DVIEWPORT9 viewport = {
+    0, 0,
+    dst_size.width(), dst_size.height(),
+    0, 1
+  };
+  device()->SetViewport(&viewport);
+
+  float halfPixelX = -1.0f / dst_size.width();
+  float halfPixelY = 1.0f / dst_size.height();
+  Vertex vertices[] = {
+    { halfPixelX - 1, halfPixelY + 1, 0.5f, 1, 0, 1 },
+    { halfPixelX + 1, halfPixelY + 1, 0.5f, 1, 1, 1 },
+    { halfPixelX + 1, halfPixelY - 1, 0.5f, 1, 1, 0 },
+    { halfPixelX - 1, halfPixelY - 1, 0.5f, 1, 0, 0 }
+  };
+
+  device()->BeginScene();
+  device()->DrawPrimitiveUP(D3DPT_TRIANGLEFAN,
+                            2,
+                            vertices,
+                            sizeof(vertices[0]));
+  device()->EndScene();
+
+  // Clear surface references.
+  device()->SetRenderTarget(0, default_color_target);
+  device()->SetTexture(0, NULL);
+  return true;
+}
+
+// Resize an RGB surface using repeated linear interpolation.
+bool AcceleratedSurfaceTransformer::ResizeBilinear(
+    IDirect3DSurface9* src_surface,
+    const gfx::Rect& src_subrect,
+    IDirect3DSurface9* dst_surface) {
+  gfx::Size src_size = GetSize(src_surface);
+  gfx::Size dst_size = GetSize(dst_surface);
+
+  if (src_size.IsEmpty() || dst_size.IsEmpty())
+    return false;
+
+  HRESULT hr = S_OK;
+  // Set up intermediate buffers needed for downsampling.
+  const int resample_count =
+      GetResampleCount(src_subrect, dst_size, src_size);
+  base::win::ScopedComPtr<IDirect3DSurface9> temp_buffer[2];
+  const gfx::Size half_size =
+      GetHalfSizeNoLessThan(src_subrect.size(), dst_size);
+  if (resample_count > 1) {
+    TRACE_EVENT0("gpu", "CreateTemporarySurface");
+    if (!d3d_utils::CreateTemporaryLockableSurface(device(),
+                                                   half_size,
+                                                   temp_buffer[0].Receive()))
+      return false;
+  }
+  if (resample_count > 2) {
+    TRACE_EVENT0("gpu", "CreateTemporarySurface");
+    const gfx::Size quarter_size = GetHalfSizeNoLessThan(half_size, dst_size);
+    if (!d3d_utils::CreateTemporaryLockableSurface(device(),
+                                                   quarter_size,
+                                                   temp_buffer[1].Receive()))
+      return false;
+  }
+
+  // Repeat downsampling the surface until its size becomes identical to
+  // |dst_size|. We keep the factor of each downsampling no more than two
+  // because using a factor more than two can introduce aliasing.
+  RECT read_rect = src_subrect.ToRECT();
+  gfx::Size write_size = half_size;
+  int read_buffer_index = 1;
+  int write_buffer_index = 0;
+  for (int i = 0; i < resample_count; ++i) {
+    TRACE_EVENT0("gpu", "StretchRect");
+    IDirect3DSurface9* read_buffer =
+        (i == 0) ? src_surface : temp_buffer[read_buffer_index];
+    IDirect3DSurface9* write_buffer =
+        (i == resample_count - 1) ? dst_surface :
+                                    temp_buffer[write_buffer_index];
+    RECT write_rect = gfx::Rect(write_size).ToRECT();
+    hr = device()->StretchRect(read_buffer,
+                               &read_rect,
+                               write_buffer,
+                               &write_rect,
+                               D3DTEXF_LINEAR);
+
+    if (FAILED(hr))
+      return false;
+    read_rect = write_rect;
+    write_size = GetHalfSizeNoLessThan(write_size, dst_size);
+    std::swap(read_buffer_index, write_buffer_index);
+  }
+
+  return true;
+}
+
+IDirect3DDevice9* AcceleratedSurfaceTransformer::device() {
+  return device_;
+}
+
+bool AcceleratedSurfaceTransformer::SetShaderCombo(ShaderCombo combo) {
+  HRESULT hr = device()->SetVertexShader(vertex_shaders_[combo]);
+  if (!SUCCEEDED(hr))
+    return false;
+  hr = device()->SetPixelShader(pixel_shaders_[combo]);
+  if (!SUCCEEDED(hr))
+    return false;
+  return true;
+}
\ No newline at end of file
diff --git a/ui/surface/accelerated_surface_transformer_win.h b/ui/surface/accelerated_surface_transformer_win.h
new file mode 100644
index 0000000..7ccd59c
--- /dev/null
+++ b/ui/surface/accelerated_surface_transformer_win.h
@@ -0,0 +1,81 @@
+// Copyright (c) 2012 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.
+
+#ifndef UI_SURFACE_ACCELERATED_SURFACE_TRANSFORMER_WIN_H_
+#define UI_SURFACE_ACCELERATED_SURFACE_TRANSFORMER_WIN_H_
+
+#include <d3d9.h>
+
+#include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
+#include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/win/scoped_comptr.h"
+#include "ui/gfx/native_widget_types.h"
+#include "ui/gfx/size.h"
+#include "ui/surface/surface_export.h"
+
+namespace gfx {
+class Size;
+class Rect;
+}  // namespace gfx
+
+// Provides useful image filtering operations that are implemented
+// efficiently on DirectX9-class hardware using fragment programs.
+class SURFACE_EXPORT AcceleratedSurfaceTransformer {
+ public:
+  // Constructs an uninitialized surface transformer. Call Init() before
+  // using the resulting object.
+  AcceleratedSurfaceTransformer();
+
+  // Init() initializes the transformer to operate on a device. This must be
+  // called before any other method of this class, and it must be called
+  // again after ReleaseAll() or DetachAll() before the class is used.
+  //
+  // Returns true if successful.
+  bool Init(IDirect3DDevice9* device);
+
+  // ReleaseAll() releases all direct3d resource references.
+  void ReleaseAll();
+
+  // DetachAll() leaks all direct3d resource references. This exists in order to
+  // work around particular driver bugs, and should only be called at shutdown.
+  // TODO(ncarter): Update the leak expectations before checkin.
+  void DetachAll();
+
+  // Draw a textured quad to a surface, flipping orientation in the y direction.
+  bool CopyInverted(
+      IDirect3DTexture9* src_texture,
+      IDirect3DSurface9* dst_surface,
+      const gfx::Size& dst_size);
+
+  // Resize a surface using repeated bilinear interpolation.
+  bool ResizeBilinear(
+    IDirect3DSurface9* src_surface,
+    const gfx::Rect& src_subrect,
+    IDirect3DSurface9* dst_surface);
+
+ private:
+  enum ShaderCombo {
+    SIMPLE_TEXTURE,
+    NUM_SHADERS
+  };
+
+  // Set the active vertex and pixel shader combination.
+  bool SetShaderCombo(ShaderCombo combo);
+
+  // Intitializes a vertex and pixel shader combination from compiled bytecode.
+  bool InitShaderCombo(const BYTE vertex_shader_instructions[],
+                       const BYTE pixel_shader_instructions[],
+                       ShaderCombo shader_combo_name);
+
+  IDirect3DDevice9* device();
+
+  base::win::ScopedComPtr<IDirect3DDevice9> device_;
+  base::win::ScopedComPtr<IDirect3DVertexShader9> vertex_shaders_[NUM_SHADERS];
+  base::win::ScopedComPtr<IDirect3DPixelShader9> pixel_shaders_[NUM_SHADERS];
+  DISALLOW_COPY_AND_ASSIGN(AcceleratedSurfaceTransformer);
+};
+
+#endif  // UI_SURFACE_ACCELERATED_SURFACE_TRANSFORMER_WIN_H_
\ No newline at end of file
diff --git a/ui/surface/accelerated_surface_win.hlsl b/ui/surface/accelerated_surface_transformer_win.hlsl
index bc87dee..0bd6fda 100644
--- a/ui/surface/accelerated_surface_win.hlsl
+++ b/ui/surface/accelerated_surface_transformer_win.hlsl
@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 // @gyp_namespace(ui_surface)
-// Compiles into C++ as 'accelerated_surface_win_hlsl_compiled.h'
+// Compiles into C++ as 'accelerated_surface_transformer_win_hlsl_compiled.h'
 
 struct Vertex {
   float4 position : POSITION;
@@ -25,4 +25,4 @@ Vertex vsOneTexture(Vertex input) {
 // Samples a texture at the given texture coordinate and returns the result.
 float4 psOneTexture(float2 texCoord : TEXCOORD0) : COLOR0 {
   return tex2D(s, texCoord);
-};
\ No newline at end of file
+};
diff --git a/ui/surface/accelerated_surface_transformer_win_unittest.cc b/ui/surface/accelerated_surface_transformer_win_unittest.cc
new file mode 100644
index 0000000..240468d
--- /dev/null
+++ b/ui/surface/accelerated_surface_transformer_win_unittest.cc
@@ -0,0 +1,424 @@
+// 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 <d3d9.h>
+#include <random>
+
+#include "base/basictypes.h"
+#include "base/hash.h"
+#include "base/scoped_native_library.h"
+#include "base/stringprintf.h"
+#include "base/win/scoped_comptr.h"
+#include "base/win/windows_version.h"
+#include "testing/gtest/include/gtest/gtest-param-test.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/rect.h"
+#include "ui/surface/accelerated_surface_transformer_win.h"
+#include "ui/surface/accelerated_surface_win.h"
+#include "ui/surface/d3d9_utils_win.h"
+
+namespace d3d_utils = ui_surface_d3d9_utils;
+
+using base::win::ScopedComPtr;
+using std::uniform_int_distribution;
+
+// Provides a reference rasterizer (all rendering done by software emulation)
+// Direct3D device, for use by unit tests.
+//
+// This class is parameterized so that it runs only on Vista+. See
+// WindowsVersionIfVistaOrBetter() for details on this works.
+class AcceleratedSurfaceTransformerTest : public testing::TestWithParam<int> {
+ public:
+  AcceleratedSurfaceTransformerTest() {};
+
+  IDirect3DDevice9Ex* device() { return device_.get(); }
+
+  virtual void SetUp() {
+    if (!d3d_module_.is_valid()) {
+      if (!d3d_utils::LoadD3D9(&d3d_module_)) {
+        GTEST_FAIL();
+        return;
+      }
+    }
+    if (!d3d_utils::CreateDevice(d3d_module_,
+                                 D3DDEVTYPE_HAL,
+                                 D3DPRESENT_INTERVAL_IMMEDIATE,
+                                 device_.Receive())) {
+      GTEST_FAIL();
+      return;
+    }
+    const ::testing::TestInfo* const test_info =
+        ::testing::UnitTest::GetInstance()->current_test_info();
+    SeedRandom("default");
+  }
+
+  virtual void TearDown() {
+    device_ = NULL;
+  }
+
+  void SeedRandom(const char* seed) {
+    rng_.seed(base::Hash(seed));
+    random_dword_.reset();
+  }
+
+  // Locks and fills a surface with a checkerboard pattern where the colors
+  // are random but the total image pattern is horizontally and vertically
+  // symmetric.
+  template<typename ColorType>
+  void FillSymmetricRandomCheckerboard(
+    IDirect3DSurface9* lockable_surface,
+    const gfx::Size& size,
+    int checker_square_size) {
+
+    D3DLOCKED_RECT locked_rect;
+    ASSERT_HRESULT_SUCCEEDED(
+        lockable_surface->LockRect(&locked_rect, NULL, D3DLOCK_DISCARD));
+    ColorType* surface = reinterpret_cast<ColorType*>(locked_rect.pBits);
+    ASSERT_EQ(0, locked_rect.Pitch % sizeof(ColorType));
+    int pitch = locked_rect.Pitch / sizeof(ColorType);
+
+    for (int y = 0; y <= size.height() / 2; y += checker_square_size) {
+      for (int x = 0; x <= size.width() / 2; x += checker_square_size) {
+        ColorType color = static_cast<ColorType>(RandomColor());
+        int y_limit = std::min(size.height() / 2, y + checker_square_size - 1);
+        int x_limit = std::min(size.width() / 2, x + checker_square_size - 1);
+        for (int y_lo = y; y_lo <= y_limit; y_lo++) {
+          for (int x_lo = x; x_lo <= x_limit; x_lo++) {
+            int y_hi = size.height() - 1 - y_lo;
+            int x_hi = size.width() - 1 - x_lo;
+            surface[x_lo + y_lo*pitch] = color;
+            surface[x_lo + y_hi*pitch] = color;
+            surface[x_hi + y_lo*pitch] = color;
+            surface[x_hi + y_hi*pitch] = color;
+          }
+        }
+      }
+    }
+
+    lockable_surface->UnlockRect();
+  }
+
+  template<typename ColorType>
+  void FillRandomCheckerboard(
+    IDirect3DSurface9* lockable_surface,
+    const gfx::Size& size,
+    int checker_square_size) {
+
+    D3DLOCKED_RECT locked_rect;
+    ASSERT_HRESULT_SUCCEEDED(
+        lockable_surface->LockRect(&locked_rect, NULL, D3DLOCK_DISCARD));
+    ColorType* surface = reinterpret_cast<ColorType*>(locked_rect.pBits);
+    ASSERT_EQ(0, locked_rect.Pitch % sizeof(ColorType));
+    int pitch = locked_rect.Pitch / sizeof(ColorType);
+
+    for (int y = 0; y <= size.height(); y += checker_square_size) {
+      for (int x = 0; x <= size.width(); x += checker_square_size) {
+        ColorType color = static_cast<ColorType>(RandomColor());
+        int y_limit = std::min(size.height(), y + checker_square_size);
+        int x_limit = std::min(size.width(), x + checker_square_size);
+        for (int square_y = y; square_y < y_limit; square_y++) {
+          for (int square_x = x; square_x < x_limit; square_x++) {
+            surface[square_x + square_y*pitch] = color;
+          }
+        }
+      }
+    }
+
+    lockable_surface->UnlockRect();
+  }
+
+  // Approximate color-equality check. Allows for some rounding error.
+  bool AssertSameColor(DWORD color_a, DWORD color_b) {
+    if (color_a == color_b)
+      return true;
+    uint8* a = reinterpret_cast<uint8*>(&color_a);
+    uint8* b = reinterpret_cast<uint8*>(&color_b);
+    int max_error = 0;
+    for (int i = 0; i < 4; i++)
+      max_error = std::max(max_error,
+          std::abs(static_cast<int>(a[i]) - b[i]));
+
+    if (max_error <= kAbsoluteColorErrorTolerance)
+      return true;
+
+    EXPECT_EQ(StringPrintf("%d %d %d %d", a[0], a[1], a[2], a[3]),
+              StringPrintf("%d %d %d %d", b[0], b[1], b[2], b[3]));
+
+    return false;
+  }
+
+  // Asserts that an image is symmetric with respect to itself: both
+  // horizontally and vertically, within the tolerance of AssertSameColor.
+  template<typename ColorType>
+  void AssertSymmetry(IDirect3DSurface9* lockable_surface,
+                      const gfx::Size& size) {
+    D3DLOCKED_RECT locked_rect;
+    ASSERT_HRESULT_SUCCEEDED(
+        lockable_surface->LockRect(&locked_rect, NULL, D3DLOCK_READONLY));
+    ASSERT_EQ(0, locked_rect.Pitch % sizeof(ColorType));
+    int pitch = locked_rect.Pitch / sizeof(ColorType);
+    ColorType* surface = reinterpret_cast<ColorType*>(locked_rect.pBits);
+    for (int y_lo = 0; y_lo < size.height() / 2; y_lo++) {
+      int y_hi = size.height() - 1 - y_lo;
+      for (int x_lo = 0; x_lo < size.width() / 2; x_lo++) {
+        int x_hi = size.width() - 1 - x_lo;
+        if (!AssertSameColor(surface[x_lo + y_lo*pitch],
+                             surface[x_hi + y_lo*pitch])) {
+          FAIL() << StringPrintf("Pixels (%d, %d) vs. (%d, %d)",
+                                 x_lo, y_lo, x_hi, y_lo);
+        }
+        if (!AssertSameColor(surface[x_hi + y_lo*pitch],
+                             surface[x_hi + y_hi*pitch])) {
+          FAIL() << StringPrintf("Pixels (%d, %d) vs. (%d, %d)",
+                                 x_hi, y_lo, x_hi, y_hi);
+        }
+        if (!AssertSameColor(surface[x_hi + y_hi*pitch],
+                               surface[x_lo + y_hi*pitch])) {
+          FAIL() << StringPrintf("Pixels (%d, %d) vs. (%d, %d)",
+                                 x_hi, y_hi, x_lo, y_hi);
+        }
+      }
+    }
+    lockable_surface->UnlockRect();
+  }
+
+  // Asserts that the actual image is a bit-identical, vertically mirrored
+  // copy of the expected image.
+  template<typename ColorType>
+  void AssertIsInvertedCopy(const gfx::Size& size,
+                            IDirect3DSurface9* expected,
+                            IDirect3DSurface9* actual) {
+
+    D3DLOCKED_RECT locked_expected, locked_actual;
+    ASSERT_HRESULT_SUCCEEDED(
+        expected->LockRect(&locked_expected, NULL, D3DLOCK_READONLY));
+    ASSERT_HRESULT_SUCCEEDED(
+        actual->LockRect(&locked_actual, NULL, D3DLOCK_READONLY));
+    ASSERT_EQ(0, locked_expected.Pitch % sizeof(ColorType));
+    int pitch = locked_expected.Pitch / sizeof(ColorType);
+    ColorType* expected_image =
+        reinterpret_cast<ColorType*>(locked_expected.pBits);
+    ColorType* actual_image =
+        reinterpret_cast<ColorType*>(locked_actual.pBits);
+    for (int y = 0; y < size.height(); y++) {
+      int y_actual = size.height() - 1 - y;
+      ASSERT_EQ(0,
+          memcmp(&expected_image[y*pitch], &actual_image[y_actual*pitch],
+                 sizeof(ColorType) * size.width()))
+          << StringPrintf("Rows not equal: %d vs. %d", y, y_actual);
+    }
+    expected->UnlockRect();
+    actual->UnlockRect();
+  }
+
+ protected:
+  static const int kAbsoluteColorErrorTolerance = 4;
+
+  DWORD RandomColor() {
+    return random_dword_(rng_);
+  }
+
+  void DoResizeBilinearTest(AcceleratedSurfaceTransformer* gpu_ops,
+                            const gfx::Size& src_size,
+                            const gfx::Size& dst_size,
+                            int checkerboard_size) {
+
+    SCOPED_TRACE(
+        StringPrintf("Resizing %dx%d -> %dx%d at checkerboard size of %d",
+                     src_size.width(), src_size.height(),
+                     dst_size.width(), dst_size.height(),
+                     checkerboard_size));
+
+    base::win::ScopedComPtr<IDirect3DSurface9> src, dst;
+    ASSERT_TRUE(d3d_utils::CreateTemporaryLockableSurface(
+        device(), src_size, src.Receive()));
+    ASSERT_TRUE(d3d_utils::CreateTemporaryLockableSurface(
+        device(), dst_size, dst.Receive()));
+
+    FillSymmetricRandomCheckerboard<DWORD>(src, src_size, checkerboard_size);
+
+    ASSERT_TRUE(gpu_ops->ResizeBilinear(src, gfx::Rect(src_size), dst));
+
+    AssertSymmetry<DWORD>(dst, dst_size);
+  }
+
+  void DoCopyInvertedTest(AcceleratedSurfaceTransformer* gpu_ops,
+                          const gfx::Size& size) {
+
+    SCOPED_TRACE(
+        StringPrintf("CopyInverted @ %dx%d", size.width(), size.height()));
+
+    base::win::ScopedComPtr<IDirect3DSurface9> checkerboard, src, dst;
+    base::win::ScopedComPtr<IDirect3DTexture9> src_texture;
+    ASSERT_TRUE(d3d_utils::CreateTemporaryLockableSurface(device(), size,
+        checkerboard.Receive()));
+    ASSERT_TRUE(d3d_utils::CreateTemporaryRenderTargetTexture(device(), size,
+        src_texture.Receive(), src.Receive()));
+    ASSERT_TRUE(d3d_utils::CreateTemporaryLockableSurface(device(), size,
+        dst.Receive()));
+
+    FillRandomCheckerboard<DWORD>(checkerboard, size, 1);
+    ASSERT_HRESULT_SUCCEEDED(
+        device()->StretchRect(checkerboard, NULL, src, NULL, D3DTEXF_NONE));
+    ASSERT_TRUE(gpu_ops->CopyInverted(src_texture, dst, size));
+    AssertIsInvertedCopy<DWORD>(size, checkerboard, dst);
+  }
+
+  uniform_int_distribution<DWORD> random_dword_;
+  std::mt19937 rng_;
+  base::ScopedNativeLibrary d3d_module_;
+  base::win::ScopedComPtr<IDirect3DDevice9Ex> device_;
+};
+
+TEST_P(AcceleratedSurfaceTransformerTest, Init) {
+  AcceleratedSurfaceTransformer gpu_ops;
+  ASSERT_TRUE(gpu_ops.Init(device()));
+};
+
+TEST_P(AcceleratedSurfaceTransformerTest, TestConsistentRandom) {
+  // This behavior should be the same for every execution on every machine.
+  // Otherwise tests might be flaky and impossible to debug.
+  SeedRandom("AcceleratedSurfaceTransformerTest.TestConsistentRandom");
+  ASSERT_EQ(2922058934, RandomColor());
+
+  SeedRandom("AcceleratedSurfaceTransformerTest.TestConsistentRandom");
+  ASSERT_EQ(2922058934, RandomColor());
+  ASSERT_EQ(4050239976, RandomColor());
+
+  SeedRandom("DifferentSeed");
+  ASSERT_EQ(3904108833, RandomColor());
+}
+
+TEST_P(AcceleratedSurfaceTransformerTest, MixedOperations) {
+  SeedRandom("MixedOperations");
+
+  AcceleratedSurfaceTransformer t;
+  ASSERT_TRUE(t.Init(device()));
+
+  DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 1);
+  DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 2);
+  DoCopyInvertedTest(&t, gfx::Size(20, 107));
+  DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 5);
+  DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(64, 64), 5);
+  DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(3, 3), 1);
+  DoCopyInvertedTest(&t, gfx::Size(1412, 124));
+  DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 1);
+  DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 2);
+
+  DoCopyInvertedTest(&t, gfx::Size(1512, 7));
+  DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 5);
+  DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 256), 8);
+  DoCopyInvertedTest(&t, gfx::Size(1521, 3));
+  DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 256), 1);
+  DoCopyInvertedTest(&t, gfx::Size(33, 712));
+  DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 8), 8);
+  DoCopyInvertedTest(&t, gfx::Size(33, 2));
+  DoResizeBilinearTest(&t, gfx::Size(200, 256), gfx::Size(126, 8), 8);
+}
+
+// Tests ResizeBilinear with 16K wide/hight src and dst surfaces.
+TEST_P(AcceleratedSurfaceTransformerTest, LargeSurfaces) {
+  SeedRandom("LargeSurfaces");
+
+  AcceleratedSurfaceTransformer gpu_ops;
+  ASSERT_TRUE(gpu_ops.Init(device()));
+
+  const int lo = 256;
+  const int hi = 16384;
+
+  DoResizeBilinearTest(&gpu_ops, gfx::Size(hi, lo), gfx::Size(lo, lo), 1);
+  DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, hi), gfx::Size(lo, lo), 1);
+  DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, lo), gfx::Size(hi, lo), lo);
+  DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, lo), gfx::Size(lo, hi), lo);
+  DoCopyInvertedTest(&gpu_ops, gfx::Size(hi, lo));
+  DoCopyInvertedTest(&gpu_ops, gfx::Size(lo, hi));
+}
+
+// Exercises ResizeBilinear with random minification cases where the
+// aspect ratio does not change.
+TEST_P(AcceleratedSurfaceTransformerTest, MinifyUniform) {
+  SeedRandom("MinifyUniform");
+
+  AcceleratedSurfaceTransformer gpu_ops;
+  ASSERT_TRUE(gpu_ops.Init(device()));
+
+  int dims[] = { 21, 63, 64, 65, 99, 127, 128, 129, 192, 255, 256, 257};
+  int checkerboards[] = {1, 2, 3, 9};
+  uniform_int_distribution<int> dim(0, arraysize(dims) - 1);
+  uniform_int_distribution<int> checkerboard(0, arraysize(checkerboards) - 1);
+
+  for (int i = 0; i < 300; i++) {
+    // Widths are picked so that dst is smaller than src.
+    int dst_width = dims[dim(rng_)];
+    int src_width = dims[dim(rng_)];
+    if (src_width < dst_width)
+      std::swap(dst_width, src_width);
+
+    // src_width is picked to preserve aspect ratio.
+    int dst_height = dims[dim(rng_)];
+    int src_height = static_cast<int>(
+        static_cast<int64>(src_width) * dst_height / dst_width);
+
+    int checkerboard_size = checkerboards[checkerboard(rng_)];
+
+    DoResizeBilinearTest(&gpu_ops,
+        gfx::Size(src_width, src_height),  // Src size (larger)
+        gfx::Size(dst_width, dst_height),  // Dst size (smaller)
+        checkerboard_size);
+  }
+};
+
+// Exercises ResizeBilinear with random magnification cases where the
+// aspect ratio does not change.
+//
+// Disabled. This test relies on an assertion that resizing preserves
+// symmetry in the image, but for the current implementation of ResizeBilinear,
+// this does not seem to be true.
+TEST_P(AcceleratedSurfaceTransformerTest, DISABLED_MagnifyUniform) {
+  SeedRandom("MagnifyUniform");
+
+  AcceleratedSurfaceTransformer gpu_ops;
+  ASSERT_TRUE(gpu_ops.Init(device()));
+
+  int dims[] = {63, 64, 65, 99, 127, 128, 129, 192, 255, 256, 257};
+  int checkerboards[] = {1, 2, 3, 9};
+  uniform_int_distribution<int> dim(0, arraysize(dims) - 1);
+  uniform_int_distribution<int> checkerboard(0, arraysize(checkerboards) - 1);
+
+  for (int i = 0; i < 50; i++) {
+    // Widths are picked so that b is smaller than a.
+    int dst_width = dims[dim(rng_)];
+    int src_width = dims[dim(rng_)];
+    if (dst_width < src_width)
+      std::swap(src_width, dst_width);
+
+    int dst_height = dims[dim(rng_)];
+    int src_height = static_cast<int>(
+        static_cast<int64>(src_width) * dst_height / dst_width);
+
+    int checkerboard_size = checkerboards[checkerboard(rng_)];
+
+    DoResizeBilinearTest(&gpu_ops,
+        gfx::Size(src_width, src_height),  // Src size (smaller)
+        gfx::Size(dst_width, dst_height),  // Dst size (larger)
+        checkerboard_size);
+  }
+};
+
+namespace {
+
+// Used to suppress test on Windows versions prior to Vista.
+std::vector<int> WindowsVersionIfVistaOrBetter() {
+  std::vector<int> result;
+  if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
+    result.push_back(base::win::GetVersion());
+  }
+  return result;
+}
+
+}  // namespace
+
+INSTANTIATE_TEST_CASE_P(VistaAndUp,
+                        AcceleratedSurfaceTransformerTest,
+                        ::testing::ValuesIn(WindowsVersionIfVistaOrBetter()));
diff --git a/ui/surface/accelerated_surface_win.cc b/ui/surface/accelerated_surface_win.cc
index acd8c64..6b4e1b1 100644
--- a/ui/surface/accelerated_surface_win.cc
+++ b/ui/surface/accelerated_surface_win.cc
@@ -8,7 +8,6 @@
 #include <windows.h>
 #include <algorithm>
 
-#include "accelerated_surface_win_hlsl_compiled.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ -30,33 +29,15 @@
 #include "ui/base/win/hwnd_util.h"
 #include "ui/gfx/rect.h"
 #include "ui/gl/gl_switches.h"
+#include "ui/surface/accelerated_surface_transformer_win.h"
+#include "ui/surface/d3d9_utils_win.h"
 
-
-using ui_surface::AcceleratedSurfaceWinHLSL::kVsOneTexture;
-using ui_surface::AcceleratedSurfaceWinHLSL::kPsOneTexture;
-
+namespace d3d_utils = ui_surface_d3d9_utils;
 
 namespace {
 
-typedef HRESULT (WINAPI *Direct3DCreate9ExFunc)(UINT sdk_version,
-                                                IDirect3D9Ex **d3d);
-
-const wchar_t kD3D9ModuleName[] = L"d3d9.dll";
-const char kCreate3D9DeviceExName[] = "Direct3DCreate9Ex";
-
 const char kUseOcclusionQuery[] = "use-occlusion-query";
 
-struct Vertex {
-  float x, y, z, w;
-  float u, v;
-};
-
-const static D3DVERTEXELEMENT9 g_vertexElements[] = {
-  { 0, 0, D3DDECLTYPE_FLOAT4, 0, D3DDECLUSAGE_POSITION, 0 },
-  { 0, 16, D3DDECLTYPE_FLOAT2, 0, D3DDECLUSAGE_TEXCOORD, 0 },
-  D3DDECL_END()
-};
-
 UINT GetPresentationInterval() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableGpuVsync))
     return D3DPRESENT_INTERVAL_IMMEDIATE;
@@ -68,53 +49,6 @@ bool UsingOcclusionQuery() {
   return CommandLine::ForCurrentProcess()->HasSwitch(kUseOcclusionQuery);
 }
 
-// Calculate the number necessary to transform |src_subrect| into |dst_size|
-// by repeating downsampling of the image of |src_subrect| by a factor no more
-// than 2.
-int GetResampleCount(const gfx::Rect& src_subrect,
-                     const gfx::Size& dst_size,
-                     const gfx::Size& back_buffer_size) {
-  // At least one copy is required, since the back buffer itself is not
-  // lockable.
-  int min_resample_count = 1;
-  int width_count = 0;
-  int width = src_subrect.width();
-  while (width > dst_size.width()) {
-    ++width_count;
-    width >>= 1;
-  }
-  int height_count = 0;
-  int height = src_subrect.height();
-  while (height > dst_size.height()) {
-    ++height_count;
-    height >>= 1;
-  }
-  return std::max(std::max(width_count, height_count),
-                  min_resample_count);
-}
-
-// Returns half the size of |size| no smaller than |min_size|.
-gfx::Size GetHalfSizeNoLessThan(const gfx::Size& size,
-                                const gfx::Size& min_size) {
-  return gfx::Size(std::max(min_size.width(), size.width() / 2),
-                   std::max(min_size.height(), size.height() / 2));
-}
-
-bool CreateTemporarySurface(IDirect3DDevice9* device,
-                            const gfx::Size& size,
-                            IDirect3DSurface9** surface) {
-  HRESULT hr = device->CreateRenderTarget(
-        size.width(),
-        size.height(),
-        D3DFMT_A8R8G8B8,
-        D3DMULTISAMPLE_NONE,
-        0,
-        TRUE,
-        surface,
-        NULL);
-  return SUCCEEDED(hr);
-}
-
 }  // namespace
 
 // A PresentThread is a thread that is dedicated to presenting surfaces to a
@@ -126,6 +60,9 @@ class PresentThread : public base::Thread,
 
   IDirect3DDevice9Ex* device() { return device_.get(); }
   IDirect3DQuery9* query() { return query_.get(); }
+  AcceleratedSurfaceTransformer* surface_transformer() {
+    return &surface_transformer_;
+  }
 
   void InitDevice();
   void ResetDevice();
@@ -141,11 +78,11 @@ class PresentThread : public base::Thread,
 
   base::ScopedNativeLibrary d3d_module_;
   base::win::ScopedComPtr<IDirect3DDevice9Ex> device_;
-
   // This query is used to wait until a certain amount of progress has been
   // made by the GPU and it is safe for the producer to modify its shared
   // texture again.
   base::win::ScopedComPtr<IDirect3DQuery9> query_;
+  AcceleratedSurfaceTransformer surface_transformer_;
 
   DISALLOW_COPY_AND_ASSIGN(PresentThread);
 };
@@ -198,7 +135,7 @@ void PresentThread::InitDevice() {
     return;
 
   TRACE_EVENT0("gpu", "PresentThread::Init");
-  d3d_module_.Reset(base::LoadNativeLibrary(FilePath(kD3D9ModuleName), NULL));
+  d3d_utils::LoadD3D9(&d3d_module_);
   ResetDevice();
 }
 
@@ -210,92 +147,32 @@ void PresentThread::ResetDevice() {
   query_ = NULL;
   device_ = NULL;
 
-  Direct3DCreate9ExFunc create_func = reinterpret_cast<Direct3DCreate9ExFunc>(
-      d3d_module_.GetFunctionPointer(kCreate3D9DeviceExName));
-  if (!create_func)
-    return;
-
-  base::win::ScopedComPtr<IDirect3D9Ex> d3d;
-  HRESULT hr = create_func(D3D_SDK_VERSION, d3d.Receive());
-  if (FAILED(hr))
-    return;
-
-  // Any old window will do to create the device. In practice the window to
-  // present to is an argument to IDirect3DDevice9::Present.
-  HWND window = GetShellWindow();
-
-  D3DPRESENT_PARAMETERS parameters = { 0 };
-  parameters.BackBufferWidth = 1;
-  parameters.BackBufferHeight = 1;
-  parameters.BackBufferCount = 1;
-  parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
-  parameters.hDeviceWindow = window;
-  parameters.Windowed = TRUE;
-  parameters.Flags = 0;
-  parameters.PresentationInterval = GetPresentationInterval();
-  parameters.SwapEffect = D3DSWAPEFFECT_COPY;
-
-  hr = d3d->CreateDeviceEx(
-      D3DADAPTER_DEFAULT,
-      D3DDEVTYPE_HAL,
-      window,
-      D3DCREATE_FPU_PRESERVE | D3DCREATE_SOFTWARE_VERTEXPROCESSING |
-          D3DCREATE_DISABLE_PSGP_THREADING | D3DCREATE_MULTITHREADED,
-      &parameters,
-      NULL,
-      device_.Receive());
-  if (FAILED(hr))
+  if (!d3d_utils::CreateDevice(d3d_module_,
+                               D3DDEVTYPE_HAL,
+                               GetPresentationInterval(),
+                               device_.Receive())) {
     return;
+  }
 
   if (UsingOcclusionQuery()) {
-    hr = device_->CreateQuery(D3DQUERYTYPE_OCCLUSION, query_.Receive());
+    HRESULT hr = device_->CreateQuery(D3DQUERYTYPE_OCCLUSION, query_.Receive());
     if (FAILED(hr)) {
       device_ = NULL;
       return;
     }
   } else {
-    hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
+    HRESULT hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
     if (FAILED(hr)) {
       device_ = NULL;
       return;
     }
   }
 
-  base::win::ScopedComPtr<IDirect3DVertexShader9> vertex_shader;
-  hr = device_->CreateVertexShader(
-      reinterpret_cast<const DWORD*>(kVsOneTexture),
-      vertex_shader.Receive());
-  if (FAILED(hr)) {
-    device_ = NULL;
+  if (!surface_transformer_.Init(device_)) {
     query_ = NULL;
-    return;
-  }
-
-  device_->SetVertexShader(vertex_shader);
-
-  base::win::ScopedComPtr<IDirect3DPixelShader9> pixel_shader;
-  hr = device_->CreatePixelShader(
-      reinterpret_cast<const DWORD*>(kPsOneTexture),
-      pixel_shader.Receive());
-
-  if (FAILED(hr)) {
     device_ = NULL;
-    query_ = NULL;
     return;
   }
-
-  device_->SetPixelShader(pixel_shader);
-
-  base::win::ScopedComPtr<IDirect3DVertexDeclaration9> vertex_declaration;
-  hr = device_->CreateVertexDeclaration(g_vertexElements,
-                                        vertex_declaration.Receive());
-  if (FAILED(hr)) {
-    device_ = NULL;
-    query_ = NULL;
-    return;
-  }
-
-  device_->SetVertexDeclaration(vertex_declaration);
 }
 
 void PresentThread::Init() {
@@ -305,6 +182,7 @@ void PresentThread::Init() {
 void PresentThread::CleanUp() {
   // The D3D device and query are leaked because destroying the associated D3D
   // query crashes some Intel drivers.
+  surface_transformer_.DetachAll();
   device_.Detach();
   query_.Detach();
 }
@@ -382,6 +260,7 @@ AcceleratedPresenter::AcceleratedPresenter(gfx::PluginWindowHandle window)
       hidden_(true) {
 }
 
+// static
 scoped_refptr<AcceleratedPresenter> AcceleratedPresenter::GetForWindow(
     gfx::PluginWindowHandle window) {
   return g_accelerated_presenter_map.Pointer()->GetPresenter(window);
@@ -467,6 +346,9 @@ bool AcceleratedPresenter::DoCopyTo(const gfx::Rect& requested_src_subrect,
   if (!swap_chain_)
     return false;
 
+  AcceleratedSurfaceTransformer* gpu_ops =
+      present_thread_->surface_transformer();
+
   base::win::ScopedComPtr<IDirect3DSurface9> back_buffer;
   HRESULT hr = swap_chain_->GetBackBuffer(0,
                                           D3DBACKBUFFER_TYPE_MONO,
@@ -487,65 +369,23 @@ bool AcceleratedPresenter::DoCopyTo(const gfx::Rect& requested_src_subrect,
   // the requested src subset. Clip to the actual back buffer.
   gfx::Rect src_subrect = requested_src_subrect;
   src_subrect.Intersect(gfx::Rect(back_buffer_size));
-
-  // Set up intermediate buffers needed for downsampling.
-  const int resample_count =
-      GetResampleCount(src_subrect, dst_size, back_buffer_size);
   base::win::ScopedComPtr<IDirect3DSurface9> final_surface;
-  base::win::ScopedComPtr<IDirect3DSurface9> temp_buffer[2];
-  if (resample_count == 0)
-    final_surface = back_buffer;
-  if (resample_count > 0) {
-    TRACE_EVENT0("gpu", "CreateTemporarySurface");
-    if (!CreateTemporarySurface(present_thread_->device(),
-                                dst_size,
-                                final_surface.Receive()))
-      return false;
-  }
-  const gfx::Size half_size =
-      GetHalfSizeNoLessThan(src_subrect.size(), dst_size);
-  if (resample_count > 1) {
-    TRACE_EVENT0("gpu", "CreateTemporarySurface");
-    if (!CreateTemporarySurface(present_thread_->device(),
-                                half_size,
-                                temp_buffer[0].Receive()))
-      return false;
-  }
-  if (resample_count > 2) {
-    TRACE_EVENT0("gpu", "CreateTemporarySurface");
-    const gfx::Size quarter_size = GetHalfSizeNoLessThan(half_size, dst_size);
-    if (!CreateTemporarySurface(present_thread_->device(),
-                                quarter_size,
-                                temp_buffer[1].Receive()))
+  {
+    TRACE_EVENT0("gpu", "CreateTemporaryLockableSurface");
+    if (!d3d_utils::CreateTemporaryLockableSurface(present_thread_->device(),
+                                                   dst_size,
+                                                   final_surface.Receive())) {
       return false;
+    }
   }
 
-  // Repeat downsampling the surface until its size becomes identical to
-  // |dst_size|. We keep the factor of each downsampling no more than two
-  // because using a factor more than two can introduce aliasing.
-  RECT read_rect = src_subrect.ToRECT();
-  gfx::Size write_size = half_size;
-  int read_buffer_index = 1;
-  int write_buffer_index = 0;
-  for (int i = 0; i < resample_count; ++i) {
-    TRACE_EVENT0("gpu", "StretchRect");
-    base::win::ScopedComPtr<IDirect3DSurface9> read_buffer =
-        (i == 0) ? back_buffer : temp_buffer[read_buffer_index];
-    base::win::ScopedComPtr<IDirect3DSurface9> write_buffer =
-        (i == resample_count - 1) ? final_surface :
-                                    temp_buffer[write_buffer_index];
-    RECT write_rect = gfx::Rect(write_size).ToRECT();
-    hr = present_thread_->device()->StretchRect(read_buffer,
-                                                &read_rect,
-                                                write_buffer,
-                                                &write_rect,
-                                                D3DTEXF_LINEAR);
-    if (FAILED(hr))
+  {
+    // Let the surface transformer start the resize into |final_surface|.
+    TRACE_EVENT0("gpu", "ResizeBilinear");
+    if (!gpu_ops->ResizeBilinear(back_buffer, src_subrect, final_surface))
       return false;
-    read_rect = write_rect;
-    write_size = GetHalfSizeNoLessThan(write_size, dst_size);
-    std::swap(read_buffer_index, write_buffer_index);
   }
+
   D3DLOCKED_RECT locked_rect;
 
   // Empirical evidence seems to suggest that LockRect and memcpy are faster
@@ -706,18 +546,13 @@ void AcceleratedPresenter::DoPresentAndAcknowledge(
   }
 
   if (!source_texture_.get()) {
-    TRACE_EVENT0("gpu", "CreateTexture");
-    HANDLE handle = reinterpret_cast<HANDLE>(surface_handle);
-    hr = present_thread_->device()->CreateTexture(size.width(),
-                                                  size.height(),
-                                                  1,
-                                                  D3DUSAGE_RENDERTARGET,
-                                                  D3DFMT_A8R8G8B8,
-                                                  D3DPOOL_DEFAULT,
-                                                  source_texture_.Receive(),
-                                                  &handle);
-    if (FAILED(hr))
+    TRACE_EVENT0("gpu", "OpenSharedTexture");
+    if (!d3d_utils::OpenSharedTexture(present_thread_->device(),
+                                      surface_handle,
+                                      size,
+                                      source_texture_.Receive())) {
       return;
+    }
   }
 
   base::win::ScopedComPtr<IDirect3DSurface9> source_surface;
@@ -744,44 +579,15 @@ void AcceleratedPresenter::DoPresentAndAcknowledge(
   {
     TRACE_EVENT0("gpu", "Copy");
 
-    // Use a simple pixel / vertex shader pair to render a quad that flips the
-    // source texture on the vertical axis.
-    IDirect3DSurface9 *default_render_target = NULL;
-    present_thread_->device()->GetRenderTarget(0, &default_render_target);
-
-    present_thread_->device()->SetRenderTarget(0, dest_surface);
-    present_thread_->device()->SetTexture(0, source_texture_);
-
-    D3DVIEWPORT9 viewport = {
-      0, 0,
-      size.width(), size.height(),
-      0, 1
-    };
-    present_thread_->device()->SetViewport(&viewport);
-
-    float halfPixelX = -1.0f / size.width();
-    float halfPixelY = 1.0f / size.height();
-    Vertex vertices[] = {
-      { halfPixelX - 1, halfPixelY + 1, 0.5f, 1, 0, 1 },
-      { halfPixelX + 1, halfPixelY + 1, 0.5f, 1, 1, 1 },
-      { halfPixelX + 1, halfPixelY - 1, 0.5f, 1, 1, 0 },
-      { halfPixelX - 1, halfPixelY - 1, 0.5f, 1, 0, 0 }
-    };
-
     if (UsingOcclusionQuery()) {
       present_thread_->query()->Issue(D3DISSUE_BEGIN);
     }
 
-    present_thread_->device()->BeginScene();
-    present_thread_->device()->DrawPrimitiveUP(D3DPT_TRIANGLEFAN,
-                                               2,
-                                               vertices,
-                                               sizeof(vertices[0]));
-    present_thread_->device()->EndScene();
-
-    present_thread_->device()->SetTexture(0, NULL);
-    present_thread_->device()->SetRenderTarget(0, default_render_target);
-    default_render_target->Release();
+    // Copy while flipping the source texture on the vertical axis.
+    bool result = present_thread_->surface_transformer()->CopyInverted(
+        source_texture_, dest_surface, size);
+    if (!result)
+      return;
   }
 
   hr = present_thread_->query()->Issue(D3DISSUE_END);
diff --git a/ui/surface/d3d9_utils_win.cc b/ui/surface/d3d9_utils_win.cc
new file mode 100644
index 0000000..85dc668
--- /dev/null
+++ b/ui/surface/d3d9_utils_win.cc
@@ -0,0 +1,119 @@
+// Copyright (c) 2012 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/surface/d3d9_utils_win.h"
+
+#include "base/file_path.h"
+#include "base/scoped_native_library.h"
+#include "base/win/scoped_comptr.h"
+#include "ui/gfx/size.h"
+
+namespace {
+
+const wchar_t kD3D9ModuleName[] = L"d3d9.dll";
+const char kCreate3D9DeviceExName[] = "Direct3DCreate9Ex";
+typedef HRESULT (WINAPI *Direct3DCreate9ExFunc)(UINT sdk_version,
+                                                IDirect3D9Ex **d3d);
+}  // namespace
+
+namespace ui_surface_d3d9_utils {
+
+bool LoadD3D9(base::ScopedNativeLibrary* storage) {
+  storage->Reset(base::LoadNativeLibrary(FilePath(kD3D9ModuleName), NULL));
+  return storage->is_valid();
+}
+
+bool CreateDevice(const base::ScopedNativeLibrary& d3d_module,
+                  D3DDEVTYPE device_type,
+                  uint32 presentation_interval,
+                  IDirect3DDevice9Ex** device) {
+
+  Direct3DCreate9ExFunc create_func = reinterpret_cast<Direct3DCreate9ExFunc>(
+      d3d_module.GetFunctionPointer(kCreate3D9DeviceExName));
+  if (!create_func)
+    return false;
+
+  base::win::ScopedComPtr<IDirect3D9Ex> d3d;
+  HRESULT hr = create_func(D3D_SDK_VERSION, d3d.Receive());
+  if (FAILED(hr))
+    return false;
+
+  // Any old window will do to create the device. In practice the window to
+  // present to is an argument to IDirect3DDevice9::Present.
+  HWND window = GetShellWindow();
+
+  D3DPRESENT_PARAMETERS parameters = { 0 };
+  parameters.BackBufferWidth = 1;
+  parameters.BackBufferHeight = 1;
+  parameters.BackBufferCount = 1;
+  parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
+  parameters.hDeviceWindow = window;
+  parameters.Windowed = TRUE;
+  parameters.Flags = 0;
+  parameters.PresentationInterval = presentation_interval;
+  parameters.SwapEffect = D3DSWAPEFFECT_COPY;
+
+  hr = d3d->CreateDeviceEx(
+      D3DADAPTER_DEFAULT,
+      device_type,
+      window,
+      D3DCREATE_FPU_PRESERVE | D3DCREATE_SOFTWARE_VERTEXPROCESSING |
+          D3DCREATE_DISABLE_PSGP_THREADING | D3DCREATE_MULTITHREADED,
+      &parameters,
+      NULL,
+      device);
+  return SUCCEEDED(hr);
+}
+
+bool OpenSharedTexture(IDirect3DDevice9* device,
+                       int64 surface_handle,
+                       const gfx::Size& size,
+                       IDirect3DTexture9** opened_texture) {
+  HANDLE handle = reinterpret_cast<HANDLE>(surface_handle);
+  HRESULT hr = device->CreateTexture(size.width(),
+                                     size.height(),
+                                     1,
+                                     D3DUSAGE_RENDERTARGET,
+                                     D3DFMT_A8R8G8B8,
+                                     D3DPOOL_DEFAULT,
+                                     opened_texture,
+                                     &handle);
+  return SUCCEEDED(hr);
+}
+
+bool CreateTemporaryLockableSurface(IDirect3DDevice9* device,
+                                    const gfx::Size& size,
+                                    IDirect3DSurface9** surface) {
+  HRESULT hr = device->CreateRenderTarget(
+        size.width(),
+        size.height(),
+        D3DFMT_A8R8G8B8,
+        D3DMULTISAMPLE_NONE,
+        0,
+        TRUE,
+        surface,
+        NULL);
+  return SUCCEEDED(hr);
+}
+
+bool CreateTemporaryRenderTargetTexture(IDirect3DDevice9* device,
+                                        const gfx::Size& size,
+                                        IDirect3DTexture9** texture,
+                                        IDirect3DSurface9** render_target) {
+  HRESULT hr = device->CreateTexture(
+        size.width(),
+        size.height(),
+        1,  // Levels
+        D3DUSAGE_RENDERTARGET,
+        D3DFMT_A8R8G8B8,
+        D3DPOOL_DEFAULT,
+        texture,
+        NULL);
+  if (!SUCCEEDED(hr))
+    return false;
+  hr = (*texture)->GetSurfaceLevel(0, render_target);
+  return SUCCEEDED(hr);
+}
+
+}  // namespace ui_surface_d3d9_utils
diff --git a/ui/surface/d3d9_utils_win.h b/ui/surface/d3d9_utils_win.h
new file mode 100644
index 0000000..5584d1b
--- /dev/null
+++ b/ui/surface/d3d9_utils_win.h
@@ -0,0 +1,71 @@
+// Copyright (c) 2012 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.
+
+// Helper functions that Direct3D 9Ex code a little easier to work with for
+// the ui/surface code.
+
+#ifndef UI_SURFACE_D3D9_UTILS_WIN_H_
+#define UI_SURFACE_D3D9_UTILS_WIN_H_
+
+#include <d3d9.h>
+
+#include "base/basictypes.h"
+#include "ui/surface/surface_export.h"
+
+namespace base {
+class ScopedNativeLibrary;
+}
+
+namespace gfx {
+class Size;
+}
+
+namespace ui_surface_d3d9_utils {
+
+// Visible for testing. Loads the Direct3D9 library. Returns true on success.
+SURFACE_EXPORT
+bool LoadD3D9(base::ScopedNativeLibrary* storage);
+
+// Visible for testing. Creates a Direct3D9 device suitable for use with the
+// accelerated surface code. Returns true on success.
+SURFACE_EXPORT
+bool CreateDevice(const base::ScopedNativeLibrary& d3d_module,
+                  D3DDEVTYPE device_type,
+                  uint32 presentation_interval,
+                  IDirect3DDevice9Ex** device);
+
+// Calls the Vista+ (WDDM1.0) variant of CreateTexture that semantically
+// opens a texture allocated (possibly in another process) as shared. The
+// shared texture is identified by its surface handle. The resulting texture
+// is written into |opened_texture|.
+//
+// Returns true on success.
+SURFACE_EXPORT
+bool OpenSharedTexture(IDirect3DDevice9* device,
+                       int64 surface_handle,
+                       const gfx::Size& size,
+                       IDirect3DTexture9** opened_texture);
+
+// Create a one-off lockable surface of a specified size.
+//
+// Returns true on success.
+SURFACE_EXPORT
+bool CreateTemporaryLockableSurface(IDirect3DDevice9* device,
+                                    const gfx::Size& size,
+                                    IDirect3DSurface9** surface);
+
+// Create a one-off renderable texture of a specified size. The texture object
+// as well as the surface object for the texture's level 0 is returned (callers
+// almost always need to use both).
+//
+// Returns true on success.
+SURFACE_EXPORT
+bool CreateTemporaryRenderTargetTexture(IDirect3DDevice9* device,
+                                        const gfx::Size& size,
+                                        IDirect3DTexture9** texture,
+                                        IDirect3DSurface9** render_target);
+
+}  // namespace ui_surface_d3d9_utils
+
+#endif  // UI_SURFACE_D3D9_UTILS_WIN_H_
\ No newline at end of file
diff --git a/ui/surface/surface.gyp b/ui/surface/surface.gyp
index d0ef432..fa08607 100644
--- a/ui/surface/surface.gyp
+++ b/ui/surface/surface.gyp
@@ -66,9 +66,13 @@
       'sources': [
         'accelerated_surface_mac.cc',
         'accelerated_surface_mac.h',
+        'accelerated_surface_transformer_win.cc',
+        'accelerated_surface_transformer_win.h',
+        'accelerated_surface_transformer_win.hlsl',
         'accelerated_surface_win.cc',
         'accelerated_surface_win.h',
-        'accelerated_surface_win.hlsl',
+        'd3d9_utils_win.cc',
+        'd3d9_utils_win.h',
         'io_surface_support_mac.cc',
         'io_surface_support_mac.h',
         'surface_export.h',