Introduce XGetImage() for GrabWindowSnapshot() in ChromeOS.

ui/aura/root_window_host_linux.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 "ui/aura/root_window_host_linux.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xcursor/Xcursor.h>
+#include <X11/Xlib.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/Xrandr.h>
 #include <algorithm>
 
 #include "base/message_pump_x.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "grit/ui_resources_standard.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/client/user_gesture_client.h"
 #include "ui/aura/dispatcher_linux.h"
 #include "ui/aura/env.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/touch/touch_factory.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/x/x11_atom_cache.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/compositor/layer.h"
+#include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image.h"
 
 using ui::X11AtomCache;
 using std::max;
 using std::min;
 
 namespace aura {
 
 namespace {
 
@@ skipping 745 matching lines @@
   static const char* k_NET_WM_USER_TIME = "_NET_WM_USER_TIME";
   focus_when_shown_ = focus_when_shown;
   if (IsWindowManagerPresent() && !focus_when_shown_) {
     ui::SetIntProperty(xwindow_,
                        k_NET_WM_USER_TIME,
                        k_NET_WM_USER_TIME,
                        0);
   }
 }
 
+bool RootWindowHostLinux::GrabSnapshot(
+    const gfx::Rect& snapshot_bounds,
+    std::vector<unsigned char>* png_representation) {
+  XImage* image = XGetImage(
+      xdisplay_, xwindow_,
+      snapshot_bounds.x(), snapshot_bounds.y(),
+      snapshot_bounds.width(), snapshot_bounds.height(),
+      AllPlanes, ZPixmap);
+
+  gfx::PNGCodec::ColorFormat color_format;
+
+  if (image->bits_per_pixel == 32) {
+    color_format = (image->byte_order == LSBFirst) ?
+        gfx::PNGCodec::FORMAT_BGRA : gfx::PNGCodec::FORMAT_RGBA;
+  } else if (image->bits_per_pixel == 24) {
+    // PNGCodec accepts FORMAT_RGB for 3 bytes per pixel:
+    color_format = gfx::PNGCodec::FORMAT_RGB;
+    if (image->byte_order == LSBFirst) {
+      LOG(WARNING) << "Converting BGR->RGB will damage the performance...";
+      int image_size =
+          image->width * image->height * image->bits_per_pixel / 8;
+      for (int i = 0; i < image_size; i += 3) {
+        char tmp = image->data[i];
+        image->data[i] = image->data[i+2];
+        image->data[i+2] = tmp;
+      }
+    }
+  } else {
+    LOG(ERROR) << "bits_per_pixel is too small";
+    XFree(image);
+    return false;
+  }
+
+  unsigned char* data = reinterpret_cast<unsigned char*>(image->data);
+  gfx::PNGCodec::Encode(data, color_format, snapshot_bounds.size(),
+                        image->width * image->bits_per_pixel / 8,
+                        true, std::vector<gfx::PNGCodec::Comment>(),
+                        png_representation);
+  XFree(image);
+  return true;
+}
+
 void RootWindowHostLinux::PostNativeEvent(
     const base::NativeEvent& native_event) {
   DCHECK(xwindow_);
   DCHECK(xdisplay_);
   XEvent xevent = *native_event;
   xevent.xany.display = xdisplay_;
   xevent.xany.window = xwindow_;
 
   switch (xevent.type) {
     case EnterNotify:
@@ skipping 52 matching lines @@
       ui::ViewProp::GetValue(accelerated_widget, kRootWindowHostLinuxKey));
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpX::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura