Implement accessibility support for CSS-transformed iframes.

ui/accessibility/ax_node_data.h

 // Copyright 2013 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_ACCESSIBILITY_AX_NODE_DATA_H_
 #define UI_ACCESSIBILITY_AX_NODE_DATA_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/strings/string16.h"
 #include "base/strings/string_split.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/accessibility/ax_export.h"
 #include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/transform.h"
 
 namespace ui {
 
 // A compact representation of the accessibility information for a
 // single accessible object, in a form that can be serialized and sent from
 // one process to another.
 struct AX_EXPORT AXNodeData {
   AXNodeData();
   virtual ~AXNodeData();
 
@@ skipping 63 matching lines @@
   virtual std::string ToString() const;
 
   bool IsRoot() const;
   void SetRoot();
 
   // This is a simple serializable struct. All member variables should be
   // public and copyable.
   int32_t id;
   AXRole role;
   uint32_t state;
-  gfx::Rect location;
   std::vector<std::pair<AXStringAttribute, std::string> > string_attributes;
   std::vector<std::pair<AXIntAttribute, int32_t>> int_attributes;
   std::vector<std::pair<AXFloatAttribute, float> > float_attributes;
   std::vector<std::pair<AXBoolAttribute, bool> > bool_attributes;
   std::vector<std::pair<AXIntListAttribute, std::vector<int32_t>>>
       intlist_attributes;
   base::StringPairs html_attributes;
   std::vector<int32_t> child_ids;
+
+  // The object's location relative to its window or frame.
+  gfx::Rect location;
+
+  // An additional transform to apply to position this object and its subtree.
+  gfx::Transform transform;

[dmazzoni, 2016/02/24 18:53:26]

Any thoughts on this? It's 16 floats, so 64 bytes of data per node, which is
annoying, and it also adds a dependency on skia to anyone who includes this
header file.

Making it scoped_ptr<gfx::Transform> would solve the space and header file
problem, but we'd have to write a copy constructor and assignment operator,
since scoped_ptr can't be copied.

It's too bad we don't have an optional<T> that's like a scoped_ptr but copyable
by default.

[danakj, 2016/02/24 19:31:45]

https://codereview.chromium.org/1245163002/ will add an Optional<T> class. But
Optional<T> holds a T, not a T*, so if gfx::Transform is too big,
Optional<gfx::Transform> will be too.

Blink has the "rare data" pattern for when there are 1000s of X but only 10s of
X::data_, where it puts that data into another object with a pointer to it on X.
Maybe that's what you want here, I'm not sure how common the AXNodeData class
is, nor how often you'll use the |transform| on it.

If you do need a rare data, a scoped_ptr is probably reasonable.

This class does seem really heavy to be copying. Why does it need to be
copyable? Is there some hopeful chance that with c++11 it can be moved instead
of copied and the need for copies can go away?

Last, adding a user-defined copy constructor will delete the default move
constructor. Because this class has STL containers in it, moving it is far far
cheaper than copying it, so I would super-recommend adding a =default move
constructor.

Last last, having a user-defined destructor also deletes the default move
constructor, so you'd benefit greatly from adding an =default move constructor
for this class in cases where the copy is from an rvalue (function return for
example) for the compiler to do a move instead.

 };
 
 }  // namespace ui
 
 #endif  // UI_ACCESSIBILITY_AX_NODE_DATA_H_