Implemented browser side software compositing.

content/browser/renderer_host/backing_store_win.cc

 // 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 "content/browser/renderer_host/backing_store_win.h"
 
 #include "base/command_line.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/public/common/content_switches.h"
@@ skipping 30 matching lines @@
     hdr.bV5Intent = LCS_GM_IMAGES;
   }
 
   void* data = NULL;
   HANDLE dib = CreateDIBSection(dc, reinterpret_cast<BITMAPINFO*>(&hdr),
                                 0, &data, NULL, 0);
   DCHECK(data);
   return dib;
 }
 
-void CallStretchDIBits(HDC hdc, int dest_x, int dest_y, int dest_w, int dest_h,
-                       int src_x, int src_y, int src_w, int src_h, void* pixels,
-                       const BITMAPINFO* bitmap_info) {
-  // When blitting a rectangle that touches the bottom, left corner of the
-  // bitmap, StretchDIBits looks at it top-down!  For more details, see
-  // http://wiki.allegro.cc/index.php?title=StretchDIBits.
-  int rv;
-  int bitmap_h = -bitmap_info->bmiHeader.biHeight;
-  int bottom_up_src_y = bitmap_h - src_y - src_h;
-  if (bottom_up_src_y == 0 && src_x == 0 && src_h != bitmap_h) {
-    rv = StretchDIBits(hdc,
-                       dest_x, dest_h + dest_y - 1, dest_w, -dest_h,
-                       src_x, bitmap_h - src_y + 1, src_w, -src_h,
-                       pixels, bitmap_info, DIB_RGB_COLORS, SRCCOPY);
-  } else {
-    rv = StretchDIBits(hdc,
-                       dest_x, dest_y, dest_w, dest_h,
-                       src_x, bottom_up_src_y, src_w, src_h,
-                       pixels, bitmap_info, DIB_RGB_COLORS, SRCCOPY);
-  }
-  DCHECK(rv != GDI_ERROR);
-}
-
 }  // namespace
 
 BackingStoreWin::BackingStoreWin(RenderWidgetHost* widget,
                                  const gfx::Size& size)
     : BackingStore(widget, size),
       backing_store_dib_(NULL),
       original_bitmap_(NULL) {
   HDC screen_dc = ::GetDC(NULL);
   color_depth_ = ::GetDeviceCaps(screen_dc, BITSPIXEL);
   // Color depths less than 16 bpp require a palette to be specified. Instead,
@@ skipping 58 matching lines @@
     original_bitmap_ = SelectObject(hdc_, backing_store_dib_);
   }
 
   TransportDIB* dib = process->GetTransportDIB(bitmap);
   if (!dib)
     return;
 
   gfx::Rect pixel_bitmap_rect = gfx::ToEnclosingRect(
       gfx::ScaleRect(bitmap_rect, scale_factor));
 
-  BITMAPINFOHEADER hdr;
+  BITMAPINFO bitmap_info;
+  memset(&bitmap_info, 0, sizeof(bitmap_info));
   gfx::CreateBitmapHeader(pixel_bitmap_rect.width(),
-                          pixel_bitmap_rect.height(), &hdr);
+                          pixel_bitmap_rect.height(),
+                          &bitmap_info.bmiHeader);
   // Account for a bitmap_rect that exceeds the bounds of our view.
   gfx::Rect view_rect(size());
 
   for (size_t i = 0; i < copy_rects.size(); i++) {
     gfx::Rect paint_rect = gfx::IntersectRects(view_rect, copy_rects[i]);
     gfx::Rect pixel_copy_rect = gfx::ToEnclosingRect(
         gfx::ScaleRect(paint_rect, scale_factor));
     gfx::Rect target_rect = pixel_copy_rect;
-    CallStretchDIBits(hdc_,
-                      target_rect.x(),
-                      target_rect.y(),
-                      target_rect.width(),
-                      target_rect.height(),
-                      pixel_copy_rect.x() - pixel_bitmap_rect.x(),
-                      pixel_copy_rect.y() - pixel_bitmap_rect.y(),
-                      pixel_copy_rect.width(),
-                      pixel_copy_rect.height(),
-                      dib->memory(),
-                      reinterpret_cast<BITMAPINFO*>(&hdr));
+    gfx::StretchDIBits(hdc_,
+                       target_rect.x(),
+                       target_rect.y(),
+                       target_rect.width(),
+                       target_rect.height(),
+                       pixel_copy_rect.x() - pixel_bitmap_rect.x(),
+                       pixel_copy_rect.y() - pixel_bitmap_rect.y(),
+                       pixel_copy_rect.width(),
+                       pixel_copy_rect.height(),
+                       dib->memory(),
+                       &bitmap_info);
   }
 }
 
 bool BackingStoreWin::CopyFromBackingStore(const gfx::Rect& rect,
                                            skia::PlatformBitmap* output) {
   // TODO(kevers): Make sure this works with HiDPI backing stores.
   if (!output->Allocate(rect.width(), rect.height(), true))
     return false;
 
   HDC temp_dc = output->GetSurface();
@@ skipping 11 matching lines @@
   float scale = ui::win::GetDeviceScaleFactor();
   gfx::Rect screen_rect = gfx::ToEnclosingRect(
       gfx::ScaleRect(clip_rect, scale));
   int dx = static_cast<int>(delta.x() * scale);
   int dy = static_cast<int>(delta.y() * scale);
   RECT damaged_rect, r = screen_rect.ToRECT();
   ScrollDC(hdc_, dx, dy, NULL, &r, NULL, &damaged_rect);
 }
 
 }  // namespace content