Move some accessibility methods, enums and interfaces into the content/public API.

content/browser/accessibility/accessibility_tree_formatter_impl.h

 // 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.
 
-#ifndef CONTENT_BROWSER_ACCESSIBILITY_DUMP_ACCESSIBILITY_TREE_HELPER_H_
-#define CONTENT_BROWSER_ACCESSIBILITY_DUMP_ACCESSIBILITY_TREE_HELPER_H_
+#ifndef CONTENT_BROWSER_ACCESSIBILITY_ACCESSIBILITY_TREE_FORMATTER_IMPL_H_
+#define CONTENT_BROWSER_ACCESSIBILITY_ACCESSIBILITY_TREE_FORMATTER_IMPL_H_
 
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/accessibility/browser_accessibility.h"
+#include "content/public/browser/accessibility_tree_formatter.h"
 
 namespace content {
 
 // A utility class for retrieving platform specific accessibility information.

[dmazzoni, 2013/02/27 16:41:01]

Maybe update this comment to say "formatting" platform-specific accessibility
information, for debugging and developer tools.

[aboxhall, 2013/02/27 18:58:50]

Done.

 // This is extended by a subclass for each platform where accessibility is
 // implemented.
-class DumpAccessibilityTreeHelper {
+class AccessibilityTreeFormatterImpl : public AccessibilityTreeFormatter {
  public:
-  DumpAccessibilityTreeHelper();
-  virtual ~DumpAccessibilityTreeHelper();
+  explicit AccessibilityTreeFormatterImpl(BrowserAccessibility* node);
+  virtual ~AccessibilityTreeFormatterImpl();
 
   // Dumps a BrowserAccessibility tree into a string.
-  void DumpAccessibilityTree(BrowserAccessibility* node,
-                             string16* contents);
+  virtual void FormatAccessibilityTree(string16* contents) OVERRIDE;
 
   // A single filter specification. See GetAllowString() and GetDenyString()
   // for more information.
   struct Filter {
     enum Type {
       ALLOW,
       ALLOW_EMPTY,
       DENY
     };
     string16 match_str;
     Type type;
 
     Filter(string16 match_str, Type type)
         : match_str(match_str), type(type) {}
   };
 
   // Set regular expression filters that apply to each component of every
   // line before it's output.
   void SetFilters(const std::vector<Filter>& filters);
 
   // Suffix of the expectation file corresponding to html file.
   // Example:
   // HTML test:      test-file.html
   // Expected:       test-file-expected-mac.txt.
   // Auto-generated: test-file-actual-mac.txt
-  const base::FilePath::StringType GetActualFileSuffix() const;
-  const base::FilePath::StringType GetExpectedFileSuffix() const;
+  static const base::FilePath::StringType GetActualFileSuffix();
+  static const base::FilePath::StringType GetExpectedFileSuffix();
 
   // A platform-specific string that indicates a given line in a file
   // is an allow-empty, allow or deny filter. Example:
   // Mac values:
   //   GetAllowEmptyString() -> "@MAC-ALLOW-EMPTY:"
   //   GetAllowString() -> "@MAC-ALLOW:"
   //   GetDenyString() -> "@MAC-DENY:"
   // Example html:
   // <!--
   // @MAC-ALLOW-EMPTY:description*
   // @MAC-ALLOW:roleDescription*
   // @MAC-DENY:subrole*
   // -->
   // <p>Text</p>
-  const std::string GetAllowEmptyString() const;
-  const std::string GetAllowString() const;
-  const std::string GetDenyString() const;
+  static const std::string GetAllowEmptyString();
+  static const std::string GetAllowString();
+  static const std::string GetDenyString();
 
  protected:
-  void RecursiveDumpAccessibilityTree(BrowserAccessibility* node,
-                                      string16* contents,
-                                      int indent);
+  void RecursiveFormatAccessibilityTree(BrowserAccessibility* node,
+                                        string16* contents,
+                                        int indent);
 
   // Returns a platform specific representation of a BrowserAccessibility.
   // Should be zero or more complete lines, each with |prefix| prepended
   // (to indent each line).
   string16 ToString(BrowserAccessibility* node, char* prefix);
 
   void Initialize();
 
-  bool MatchesFilters(const string16& text, bool default_result);
+  bool MatchesFilters(const string16& text, bool default_result) const;
   void StartLine();
   void Add(bool include_by_default, const string16& attr);
   string16 FinishLine();
 
+  BrowserAccessibility* node_;
   std::vector<Filter> filters_;
   string16 line_;
 
-  DISALLOW_COPY_AND_ASSIGN(DumpAccessibilityTreeHelper);
+  DISALLOW_COPY_AND_ASSIGN(AccessibilityTreeFormatterImpl);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_ACCESSIBILITY_DUMP_ACCESSIBILITY_TREE_HELPER_H_
+#endif  // CONTENT_BROWSER_ACCESSIBILITY_ACCESSIBILITY_TREE_FORMATTER_IMPL_H_