Snapshot of all changes to get jumbo in blink and content.

ui/base/x/x11_util.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.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
@@ skipping 78 matching lines @@
   LOG(ERROR) << "X IO error received (X server probably went away)";
   _exit(1);
 }
 
 // Note: The caller should free the resulting value data.
 bool GetProperty(XID window, const std::string& property_name, long max_length,
                  XAtom* type, int* format, unsigned long* num_items,
                  unsigned char** property) {
   XAtom property_atom = gfx::GetAtom(property_name.c_str());
   unsigned long remaining_bytes = 0;
-  return XGetWindowProperty(gfx::GetXDisplay(),
-                            window,
-                            property_atom,
-                            0,          // offset into property data to read
-                            max_length, // max length to get
-                            False,      // deleted
-                            AnyPropertyType,
-                            type,
-                            format,
-                            num_items,
-                            &remaining_bytes,
-                            property);
+  return XGetWindowProperty(gfx::GetXDisplay(), window, property_atom,
+                            0,           // offset into property data to read
+                            max_length,  // max length to get
+                            X11Constants::False,  // deleted
+                            AnyPropertyType, type, format, num_items,
+                            &remaining_bytes, property);
 }
 
 bool SupportsEWMH() {
   static bool supports_ewmh = false;
   static bool supports_ewmh_cached = false;
   if (!supports_ewmh_cached) {
     supports_ewmh_cached = true;
 
     int wm_window = 0u;
     if (!GetIntProperty(GetX11RootWindow(),
@@ skipping 502 matching lines @@
       }
     }
     if (!is_in_shape_rects)
       return false;
   }
   return true;
 }
 
 
 bool PropertyExists(XID window, const std::string& property_name) {
-  XAtom type = None;
+  XAtom type = X11Constants::None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1,
                            &type, &format, &num_items, &property);
   gfx::XScopedPtr<unsigned char> scoped_property(property);
-  if (result != Success)
+  if (result != X11Constants::Success)
     return false;
 
   return num_items > 0;
 }
 
 bool GetRawBytesOfProperty(XID window,
                            XAtom property,
                            scoped_refptr<base::RefCountedMemory>* out_data,
                            size_t* out_data_items,
                            XAtom* out_type) {
   // Retrieve the data from our window.
   unsigned long nitems = 0;
   unsigned long nbytes = 0;
-  XAtom prop_type = None;
+  XAtom prop_type = X11Constants::None;
   int prop_format = 0;
   unsigned char* property_data = NULL;
-  if (XGetWindowProperty(gfx::GetXDisplay(), window, property,
-                         0, 0x1FFFFFFF /* MAXINT32 / 4 */, False,
-                         AnyPropertyType, &prop_type, &prop_format,
-                         &nitems, &nbytes, &property_data) != Success) {
+  if (XGetWindowProperty(gfx::GetXDisplay(), window, property, 0,
+                         0x1FFFFFFF /* MAXINT32 / 4 */, X11Constants::False,
+                         AnyPropertyType, &prop_type, &prop_format, &nitems,
+                         &nbytes, &property_data) != X11Constants::Success) {
     return false;
   }
   gfx::XScopedPtr<unsigned char> scoped_property(property_data);
 
-  if (prop_type == None)
+  if (prop_type == X11Constants::None)
     return false;
 
   size_t bytes = 0;
   // So even though we should theoretically have nbytes (and we can't
   // pass NULL there), we need to manually calculate the byte length here
   // because nbytes always returns zero.
   switch (prop_format) {
     case 8:
       bytes = nitems;
       break;
@@ skipping 14 matching lines @@
   if (out_data_items)
     *out_data_items = nitems;
 
   if (out_type)
     *out_type = prop_type;
 
   return true;
 }
 
 bool GetIntProperty(XID window, const std::string& property_name, int* value) {
-  XAtom type = None;
+  XAtom type = X11Constants::None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1,
                            &type, &format, &num_items, &property);
   gfx::XScopedPtr<unsigned char> scoped_property(property);
-  if (result != Success)
+  if (result != X11Constants::Success)
     return false;
 
   if (format != 32 || num_items != 1)
     return false;
 
   *value = static_cast<int>(*(reinterpret_cast<long*>(property)));
   return true;
 }
 
 bool GetXIDProperty(XID window, const std::string& property_name, XID* value) {
-  XAtom type = None;
+  XAtom type = X11Constants::None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1,
                            &type, &format, &num_items, &property);
   gfx::XScopedPtr<unsigned char> scoped_property(property);
-  if (result != Success)
+  if (result != X11Constants::Success)
     return false;
 
   if (format != 32 || num_items != 1)
     return false;
 
   *value = *(reinterpret_cast<XID*>(property));
   return true;
 }
 
 bool GetIntArrayProperty(XID window,
                          const std::string& property_name,
                          std::vector<int>* value) {
-  XAtom type = None;
+  XAtom type = X11Constants::None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* properties = NULL;
 
   int result = GetProperty(window, property_name,
                            (~0L), // (all of them)
                            &type, &format, &num_items, &properties);
   gfx::XScopedPtr<unsigned char> scoped_properties(properties);
-  if (result != Success)
+  if (result != X11Constants::Success)
     return false;
 
   if (format != 32)
     return false;
 
   long* int_properties = reinterpret_cast<long*>(properties);
   value->clear();
   for (unsigned long i = 0; i < num_items; ++i) {
     value->push_back(static_cast<int>(int_properties[i]));
   }
   return true;
 }
 
 bool GetAtomArrayProperty(XID window,
                           const std::string& property_name,
                           std::vector<XAtom>* value) {
-  XAtom type = None;
+  XAtom type = X11Constants::None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* properties = NULL;
 
   int result = GetProperty(window, property_name,
                            (~0L), // (all of them)
                            &type, &format, &num_items, &properties);
   gfx::XScopedPtr<unsigned char> scoped_properties(properties);
-  if (result != Success)
+  if (result != X11Constants::Success)
     return false;
 
   if (type != XA_ATOM)
     return false;
 
   XAtom* atom_properties = reinterpret_cast<XAtom*>(properties);
   value->clear();
   value->insert(value->begin(), atom_properties, atom_properties + num_items);
   return true;
 }
 
 bool GetStringProperty(
     XID window, const std::string& property_name, std::string* value) {
-  XAtom type = None;
+  XAtom type = X11Constants::None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1024,
                            &type, &format, &num_items, &property);
   gfx::XScopedPtr<unsigned char> scoped_property(property);
-  if (result != Success)
+  if (result != X11Constants::Success)
     return false;
 
   if (format != 8)
     return false;
 
   value->assign(reinterpret_cast<char*>(property), num_items);
   return true;
 }
 
 bool SetIntProperty(XID window,
@@ skipping 229 matching lines @@
   }
 }
 
 bool GetXWindowStack(Window window, std::vector<XID>* windows) {
   windows->clear();
 
   Atom type;
   int format;
   unsigned long count;
   unsigned char *data = NULL;
-  if (GetProperty(window,
-                  "_NET_CLIENT_LIST_STACKING",
-                  ~0L,
-                  &type,
-                  &format,
-                  &count,
-                  &data) != Success) {
+  if (GetProperty(window, "_NET_CLIENT_LIST_STACKING", ~0L, &type, &format,
+                  &count, &data) != X11Constants::Success) {
     return false;
   }
   gfx::XScopedPtr<unsigned char> scoped_data(data);
 
   bool result = false;
   if (type == XA_WINDOW && format == 32 && data && count > 0) {
     result = true;
     XID* stack = reinterpret_cast<XID*>(data);
     for (long i = static_cast<long>(count) - 1; i >= 0; i--)
       windows->push_back(stack[i]);
@@ skipping 101 matching lines @@
 
 std::string GuessWindowManagerName() {
   std::string name;
   if (GetWindowManagerName(&name))
     return name;
   return "Unknown";
 }
 
 bool IsCompositingManagerPresent() {
   static bool is_compositing_manager_present =
-      XGetSelectionOwner(gfx::GetXDisplay(), gfx::GetAtom("_NET_WM_CM_S0")) !=
-      None;
+      XGetSelectionOwner(gfx::GetXDisplay(),
+                         gfx::GetAtom("_NET_WM_CM_S0")) != X11Constants::None;
   return is_compositing_manager_present;
 }
 
 void SetDefaultX11ErrorHandlers() {
   SetX11ErrorHandlers(NULL, NULL);
 }
 
 bool IsX11WindowFullScreen(XID window) {
   // If _NET_WM_STATE_FULLSCREEN is in _NET_SUPPORTED, use the presence or
   // absence of _NET_WM_STATE_FULLSCREEN in _NET_WM_STATE to determine
@@ skipping 182 matching lines @@
       have_gpu_argb_visual_(false) {
   int visuals_len = 0;
   XVisualInfo visual_template;
   visual_template.screen = DefaultScreen(display_);
   gfx::XScopedPtr<XVisualInfo[]> visual_list(XGetVisualInfo(
       display_, VisualScreenMask, &visual_template, &visuals_len));
   for (int i = 0; i < visuals_len; ++i)
     visuals_[visual_list[i].visualid].reset(new XVisualData(visual_list[i]));
 
   XAtom NET_WM_CM_S0 = gfx::GetAtom("_NET_WM_CM_S0");
-  using_compositing_wm_ = XGetSelectionOwner(display_, NET_WM_CM_S0) != None;
+  using_compositing_wm_ = XGetSelectionOwner(display_, NET_WM_CM_S0) != X11Constants::None;
 
   // Choose the opaque visual.
   default_visual_id_ =
       XVisualIDFromVisual(DefaultVisual(display_, DefaultScreen(display_)));
   system_visual_id_ = default_visual_id_;
   DCHECK(system_visual_id_);
   DCHECK(visuals_.find(system_visual_id_) != visuals_.end());
 
   // Choose the transparent visual.
   for (const auto& pair : visuals_) {
@@ skipping 75 matching lines @@
                                 visual_info.visual, AllocNone);
   }
   return colormap_;
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui