1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "ui/snapshot/snapshot_win.h"
6
7#include "base/callback.h"
8#include "base/win/scoped_gdi_object.h"
9#include "base/win/scoped_hdc.h"
10#include "base/win/scoped_select_object.h"
11#include "ui/gfx/codec/png_codec.h"
12#include "ui/gfx/gdi_util.h"
13#include "ui/gfx/rect.h"
14#include "ui/gfx/size.h"
15#include "ui/snapshot/snapshot.h"
16
17namespace {
18
19gfx::Rect GetWindowBounds(HWND window_handle) {
20  RECT content_rect = {0, 0, 0, 0};
21  if (window_handle) {
22    ::GetWindowRect(window_handle, &content_rect);
23  } else {
24    MONITORINFO monitor_info = {};
25    monitor_info.cbSize = sizeof(monitor_info);
26    if (GetMonitorInfo(MonitorFromWindow(NULL, MONITOR_DEFAULTTOPRIMARY),
27                       &monitor_info)) {
28      content_rect = monitor_info.rcMonitor;
29    }
30  }
31  content_rect.right++;  // Match what PrintWindow wants.
32
33  return gfx::Rect(content_rect.right - content_rect.left,
34                   content_rect.bottom - content_rect.top);
35}
36
37}  // namespace
38
39namespace ui {
40
41namespace internal {
42
43bool GrabHwndSnapshot(HWND window_handle,
44                      const gfx::Rect& snapshot_bounds,
45                      std::vector<unsigned char>* png_representation) {
46  DCHECK(snapshot_bounds.right() <= GetWindowBounds(window_handle).right());
47  DCHECK(snapshot_bounds.bottom() <= GetWindowBounds(window_handle).bottom());
48
49  // Create a memory DC that's compatible with the window.
50  HDC window_hdc = GetWindowDC(window_handle);
51  base::win::ScopedCreateDC mem_hdc(CreateCompatibleDC(window_hdc));
52
53  BITMAPINFOHEADER hdr;
54  gfx::CreateBitmapHeader(snapshot_bounds.width(),
55                          snapshot_bounds.height(),
56                          &hdr);
57  unsigned char *bit_ptr = NULL;
58  base::win::ScopedBitmap bitmap(
59      CreateDIBSection(mem_hdc.Get(),
60                       reinterpret_cast<BITMAPINFO*>(&hdr),
61                       DIB_RGB_COLORS,
62                       reinterpret_cast<void **>(&bit_ptr),
63                       NULL, 0));
64
65  base::win::ScopedSelectObject select_bitmap(mem_hdc.Get(), bitmap);
66  // Clear the bitmap to white (so that rounded corners on windows
67  // show up on a white background, and strangely-shaped windows
68  // look reasonable). Not capturing an alpha mask saves a
69  // bit of space.
70  PatBlt(mem_hdc.Get(), 0, 0, snapshot_bounds.width(), snapshot_bounds.height(),
71         WHITENESS);
72  // Grab a copy of the window
73  // First, see if PrintWindow is defined (it's not in Windows 2000).
74  typedef BOOL (WINAPI *PrintWindowPointer)(HWND, HDC, UINT);
75  PrintWindowPointer print_window =
76      reinterpret_cast<PrintWindowPointer>(
77          GetProcAddress(GetModuleHandle(L"User32.dll"), "PrintWindow"));
78
79  // If PrintWindow is defined, use it.  It will work on partially
80  // obscured windows, and works better for out of process sub-windows.
81  // Otherwise grab the bits we can get with BitBlt; it's better
82  // than nothing and will work fine in the average case (window is
83  // completely on screen).  Always BitBlt when grabbing the whole screen.
84  if (snapshot_bounds.origin() == gfx::Point() && print_window && window_handle)
85    (*print_window)(window_handle, mem_hdc.Get(), 0);
86  else
87    BitBlt(mem_hdc.Get(), 0, 0, snapshot_bounds.width(),
88           snapshot_bounds.height(), window_hdc, snapshot_bounds.x(),
89           snapshot_bounds.y(), SRCCOPY);
90
91  // We now have a copy of the window contents in a DIB, so
92  // encode it into a useful format for posting to the bug report
93  // server.
94  gfx::PNGCodec::Encode(bit_ptr, gfx::PNGCodec::FORMAT_BGRA,
95                        snapshot_bounds.size(),
96                        snapshot_bounds.width() * 4, true,
97                        std::vector<gfx::PNGCodec::Comment>(),
98                        png_representation);
99
100  ReleaseDC(window_handle, window_hdc);
101
102  return true;
103}
104
105}  // namespace internal
106
107#if !defined(USE_AURA)
108
109bool GrabViewSnapshot(gfx::NativeView view_handle,
110                      std::vector<unsigned char>* png_representation,
111                      const gfx::Rect& snapshot_bounds) {
112  return GrabWindowSnapshot(view_handle, png_representation, snapshot_bounds);
113}
114
115bool GrabWindowSnapshot(gfx::NativeWindow window_handle,
116                        std::vector<unsigned char>* png_representation,
117                        const gfx::Rect& snapshot_bounds) {
118  DCHECK(window_handle);
119  return internal::GrabHwndSnapshot(window_handle, snapshot_bounds,
120                                    png_representation);
121}
122
123void GrapWindowSnapshotAsync(
124    gfx::NativeWindow window,
125    const gfx::Rect& snapshot_bounds,
126    const gfx::Size& target_size,
127    scoped_refptr<base::TaskRunner> background_task_runner,
128    GrabWindowSnapshotAsyncCallback callback) {
129  callback.Run(gfx::Image());
130}
131
132void GrabViewSnapshotAsync(
133    gfx::NativeView view,
134    const gfx::Rect& source_rect,
135    scoped_refptr<base::TaskRunner> background_task_runner,
136    const GrabWindowSnapshotAsyncPNGCallback& callback) {
137  callback.Run(scoped_refptr<base::RefCountedBytes>());
138}
139
140
141void GrabWindowSnapshotAsync(
142    gfx::NativeWindow window,
143    const gfx::Rect& source_rect,
144    scoped_refptr<base::TaskRunner> background_task_runner,
145    const GrabWindowSnapshotAsyncPNGCallback& callback) {
146  callback.Run(scoped_refptr<base::RefCountedBytes>());
147}
148
149#endif  // !defined(USE_AURA)
150
151}  // namespace ui
152