Rename DumpAccesibilityTreeHelper to AccessibilityTreeFormatter, pull into content/browser.

content/browser/accessibility/dump_accessibility_tree_browsertest.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 <set>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/string16.h"
 #include "base/strings/string_split.h"
 #include "base/utf_string_conversions.h"
+#include "content/browser/accessibility/accessibility_tree_formatter_impl.h"
 #include "content/browser/accessibility/browser_accessibility.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
-#include "content/browser/accessibility/dump_accessibility_tree_helper.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/accessibility_mode.h"

[dmazzoni, 2013/02/28 18:59:12]

This doesn't exist anymore, right?

[aboxhall, 2013/02/28 22:12:59]

Done.

 #include "content/public/common/content_paths.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/shell.h"
 #include "content/test/content_browser_test.h"
 #include "content/test/content_browser_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
   static const char kCommentToken = '#';
   static const char* kMarkSkipFile = "#<skip";
   static const char* kMarkEndOfFile = "<-- End-of-file -->";
   static const char* kSignalDiff = "*";
 } // namespace
 
 namespace content {
 
-typedef DumpAccessibilityTreeHelper::Filter Filter;
+typedef AccessibilityTreeFormatter::Filter Filter;
 
 // This test takes a snapshot of the platform BrowserAccessibility tree and
 // tests it against an expected baseline.
 //
 // The flow of the test is as outlined below.
 // 1. Load an html file from chrome/test/data/accessibility.
 // 2. Read the expectation.
 // 3. Browse to the page and serialize the platform specific tree into a human
 //    readable string.
 // 4. Perform a comparison between actual and expected and fail if they do not
@@ skipping 33 matching lines @@
   }
 
   void ParseFilters(const std::string& test_html,
                     std::vector<Filter>* filters) {
     std::vector<std::string> lines;
     base::SplitString(test_html, '\n', &lines);
     for (std::vector<std::string>::const_iterator iter = lines.begin();
          iter != lines.end();
          ++iter) {
       const std::string& line = *iter;
-      const std::string& allow_empty_str = helper_.GetAllowEmptyString();
-      const std::string& allow_str = helper_.GetAllowString();
-      const std::string& deny_str = helper_.GetDenyString();
+      const std::string& allow_empty_str =
+          AccessibilityTreeFormatter::GetAllowEmptyString();
+      const std::string& allow_str =
+          AccessibilityTreeFormatter::GetAllowString();
+      const std::string& deny_str =
+          AccessibilityTreeFormatter::GetDenyString();
       if (StartsWithASCII(line, allow_empty_str, true)) {
         filters->push_back(
           Filter(UTF8ToUTF16(line.substr(allow_empty_str.size())),
                  Filter::ALLOW_EMPTY));
       } else if (StartsWithASCII(line, allow_str, true)) {
         filters->push_back(Filter(UTF8ToUTF16(line.substr(allow_str.size())),
                                   Filter::ALLOW));
       } else if (StartsWithASCII(line, deny_str, true)) {
         filters->push_back(Filter(UTF8ToUTF16(line.substr(deny_str.size())),
                                   Filter::DENY));
       }
     }
   }
 
   void RunTest(const base::FilePath::CharType* file_path);
-
-  DumpAccessibilityTreeHelper helper_;
 };
 
 void DumpAccessibilityTreeTest::RunTest(
     const base::FilePath::CharType* file_path) {
   NavigateToURL(shell(), GURL("about:blank"));
   RenderWidgetHostViewPort* host_view = static_cast<RenderWidgetHostViewPort*>(
       shell()->web_contents()->GetRenderWidgetHostView());
   RenderWidgetHostImpl* host =
       RenderWidgetHostImpl::From(host_view->GetRenderWidgetHost());
   RenderViewHostImpl* view_host = static_cast<RenderViewHostImpl*>(host);
   view_host->set_save_accessibility_tree_for_testing(true);
-  view_host->SetAccessibilityMode(AccessibilityModeComplete);
+  view_host->SetAccessibilityMode(ACCESSIBILITY_MODE_COMPLETE);
 
   // Setup test paths.
   base::FilePath dir_test_data;
   ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &dir_test_data));
   base::FilePath test_path(
       dir_test_data.Append(FILE_PATH_LITERAL("accessibility")));
   ASSERT_TRUE(file_util::PathExists(test_path))
       << test_path.LossyDisplayName();
 
   base::FilePath html_file = test_path.Append(base::FilePath(file_path));
   // Output the test path to help anyone who encounters a failure and needs
   // to know where to look.
   printf("Testing: %s\n", html_file.MaybeAsASCII().c_str());
 
   std::string html_contents;
   file_util::ReadFileToString(html_file, &html_contents);
 
-  // Parse filters in the test file.
-  std::vector<Filter> filters;
-  AddDefaultFilters(&filters);
-  ParseFilters(html_contents, &filters);
-  helper_.SetFilters(filters);
-
   // Read the expected file.
   std::string expected_contents_raw;
   base::FilePath expected_file =
     base::FilePath(html_file.RemoveExtension().value() +
-             helper_.GetExpectedFileSuffix());
+                   AccessibilityTreeFormatter::GetExpectedFileSuffix());
   file_util::ReadFileToString(
       expected_file,
       &expected_contents_raw);
 
   // Tolerate Windows-style line endings (\r\n) in the expected file:
   // normalize by deleting all \r from the file (if any) to leave only \n.
   std::string expected_contents;
   RemoveChars(expected_contents_raw, "\r", &expected_contents);
 
   if (!expected_contents.compare(0, strlen(kMarkSkipFile), kMarkSkipFile)) {
     printf("Skipping this test on this platform.\n");
     return;
   }
 
   // Load the page.
   WindowedNotificationObserver tree_updated_observer(
       NOTIFICATION_ACCESSIBILITY_LOAD_COMPLETE,
       NotificationService::AllSources());
   string16 html_contents16;
   html_contents16 = UTF8ToUTF16(html_contents);
   GURL url = GetTestUrl("accessibility",
                         html_file.BaseName().MaybeAsASCII().c_str());
   NavigateToURL(shell(), url);
 
   // Wait for the tree.
   tree_updated_observer.Wait();
+  AccessibilityTreeFormatter formatter(
+      host_view->GetBrowserAccessibilityManager()->GetRoot());
+
+  // Parse filters in the test file.
+  std::vector<Filter> filters;
+  AddDefaultFilters(&filters);
+  ParseFilters(html_contents, &filters);
+  formatter.SetFilters(filters);
 
   // Perform a diff (or write the initial baseline).
   string16 actual_contents_utf16;
-  helper_.DumpAccessibilityTree(
-      host_view->GetBrowserAccessibilityManager()->GetRoot(),
-      &actual_contents_utf16);
+  formatter.FormatAccessibilityTree(&actual_contents_utf16);
   std::string actual_contents = UTF16ToUTF8(actual_contents_utf16);
   std::vector<std::string> actual_lines, expected_lines;
   Tokenize(actual_contents, "\n", &actual_lines);
   Tokenize(expected_contents, "\n", &expected_lines);
   // Marking the end of the file with a line of text ensures that
   // file length differences are found.
   expected_lines.push_back(kMarkEndOfFile);
   actual_lines.push_back(kMarkEndOfFile);
 
   std::vector<int> diff_lines = DiffLines(expected_lines, actual_lines);
@@ skipping 16 matching lines @@
              expected_lines[line].c_str());
     }
     printf("\nActual\n");
     printf("------\n");
     printf("%s\n", actual_contents.c_str());
   }
 
   if (!file_util::PathExists(expected_file)) {
     base::FilePath actual_file =
         base::FilePath(html_file.RemoveExtension().value() +
-                       helper_.GetActualFileSuffix());
+                       AccessibilityTreeFormatter::GetActualFileSuffix());
 
     EXPECT_TRUE(file_util::WriteFile(
         actual_file, actual_contents.c_str(), actual_contents.size()));
 
     ADD_FAILURE() << "No expectation found. Create it by doing:\n"
                   << "mv " << actual_file.LossyDisplayName() << " "
                   << expected_file.LossyDisplayName();
   }
 }
 
@@ skipping 202 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityUl) {
   RunTest(FILE_PATH_LITERAL("ul.html"));
 }
 
 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityWbr) {
   RunTest(FILE_PATH_LITERAL("wbr.html"));
 }
 
 }  // namespace content