// Copyright 2019 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 "content/browser/accessibility/accessibility_tree_formatter_uia_win.h"

#include <math.h>
#include <oleacc.h>
#include <stddef.h>
#include <stdint.h>
#include <uiautomation.h>
#include <wrl/client.h>

#include <iostream>
#include <memory>
#include <string>
#include <utility>

#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "base/win/com_init_util.h"
#include "base/win/scoped_bstr.h"
#include "base/win/scoped_variant.h"
#include "base/win/windows_version.h"
#include "content/browser/accessibility/accessibility_tree_formatter_utils_win.h"
#include "content/browser/accessibility/browser_accessibility_manager.h"
#include "ui/accessibility/accessibility_switches.h"
#include "ui/gfx/win/hwnd_util.h"

namespace {

base::string16 UiaIdentifierToCondensedString16(int32_t id) {
  base::string16 identifier = content::UiaIdentifierToString(id);
  if (id >= UIA_RuntimeIdPropertyId && id <= UIA_HeadingLevelPropertyId) {
    // remove leading 'UIA_' and trailing 'PropertyId'
    return identifier.substr(4, identifier.size() - 14);
  }
  return identifier;
}

std::string UiaIdentifierToCondensedString(int32_t id) {
  return base::UTF16ToUTF8(UiaIdentifierToCondensedString16(id));
}

}  // namespace

namespace content {

// This is the list of interesting properties to dump.
//
// Certain properties are skipped because they are known to cause crashes if the
// underlying pattern isn't implemented (e.g., LegacyIAccessibleSelection will
// crash on Win7 if the LegacyIAccessible pattern isn't implemented).
//
// Other properties aren't interesting in a tree-dump context (e.g., ProcessId).
//
// Finally, certain properties are dumped as part of a pattern, and don't need
// to be dumped a second time here (e.g., Grid*, GridItem*, RangeValue*, etc.).

// static
const long AccessibilityTreeFormatterUia::properties_[] = {
    // UIA_RuntimeIdPropertyId                          // 30000
    UIA_BoundingRectanglePropertyId,                    // 30001
    // UIA_ProcessIdPropertyId                          // 30002
    UIA_ControlTypePropertyId,                          // 30003
    UIA_LocalizedControlTypePropertyId,                 // 30004
    UIA_NamePropertyId,                                 // 30005
    UIA_AcceleratorKeyPropertyId,                       // 30006
    UIA_AccessKeyPropertyId,                            // 30007
    UIA_HasKeyboardFocusPropertyId,                     // 30008
    UIA_IsKeyboardFocusablePropertyId,                  // 30009
    UIA_IsEnabledPropertyId,                            // 30010
    UIA_AutomationIdPropertyId,                         // 30011
    UIA_ClassNamePropertyId,                            // 30012
    UIA_HelpTextPropertyId,                             // 30013
    UIA_ClickablePointPropertyId,                       // 30014
    UIA_CulturePropertyId,                              // 30015
    UIA_IsControlElementPropertyId,                     // 30016
    UIA_IsContentElementPropertyId,                     // 30017
    UIA_LabeledByPropertyId,                            // 30018
    UIA_IsPasswordPropertyId,                           // 30019
    // UIA_NativeWindowHandlePropertyId                 // 30020
    UIA_ItemTypePropertyId,                             // 30021
    UIA_IsOffscreenPropertyId,                          // 30022
    UIA_OrientationPropertyId,                          // 30023
    UIA_FrameworkIdPropertyId,                          // 30024
    UIA_IsRequiredForFormPropertyId,                    // 30025
    UIA_ItemStatusPropertyId,                           // 30026
    UIA_IsDockPatternAvailablePropertyId,               // 30027
    UIA_IsExpandCollapsePatternAvailablePropertyId,     // 30028
    UIA_IsGridItemPatternAvailablePropertyId,           // 30029
    UIA_IsGridPatternAvailablePropertyId,               // 30030
    UIA_IsInvokePatternAvailablePropertyId,             // 30031
    UIA_IsMultipleViewPatternAvailablePropertyId,       // 30032
    UIA_IsRangeValuePatternAvailablePropertyId,         // 30033
    UIA_IsScrollPatternAvailablePropertyId,             // 30034
    UIA_IsScrollItemPatternAvailablePropertyId,         // 30035
    UIA_IsSelectionItemPatternAvailablePropertyId,      // 30036
    UIA_IsSelectionPatternAvailablePropertyId,          // 30037
    UIA_IsTablePatternAvailablePropertyId,              // 30038
    UIA_IsTableItemPatternAvailablePropertyId,          // 30039
    UIA_IsTextPatternAvailablePropertyId,               // 30040
    UIA_IsTogglePatternAvailablePropertyId,             // 30041
    UIA_IsTransformPatternAvailablePropertyId,          // 30042
    UIA_IsValuePatternAvailablePropertyId,              // 30043
    UIA_IsWindowPatternAvailablePropertyId,             // 30044
    // UIA_Value*                                       // 30045-30046
    // UIA_RangeValue*                                  // 30047-30052
    // UIA_Scroll*                                      // 30053-30058
    UIA_SelectionSelectionPropertyId,                   // 30059
    // UIA_Selection*                                   // 30060-30061
    // UIA_Grid*                                        // 30062-30068
    UIA_DockDockPositionPropertyId,                     // 30069
    UIA_ExpandCollapseExpandCollapseStatePropertyId,    // 30070
    UIA_MultipleViewCurrentViewPropertyId,              // 30071
    UIA_MultipleViewSupportedViewsPropertyId,           // 30072
    UIA_WindowCanMaximizePropertyId,                    // 30073
    UIA_WindowCanMinimizePropertyId,                    // 30074
    UIA_WindowWindowVisualStatePropertyId,              // 30075
    UIA_WindowWindowInteractionStatePropertyId,         // 30076
    // UIA_WindowIsModalPropertyId                      // 30077
    UIA_WindowIsTopmostPropertyId,                      // 30078
    // UIA_SelectionItem*                               // 30079-30080
    UIA_TableRowHeadersPropertyId,                      // 30081
    UIA_TableColumnHeadersPropertyId,                   // 30082
    // UIA_TableRowOrColumnMajorPropertyId              // 30083
    UIA_TableItemRowHeaderItemsPropertyId,              // 30084
    UIA_TableItemColumnHeaderItemsPropertyId,           // 30085
    // UIA_ToggleToggleStatePropertyId                  // 30086
    UIA_TransformCanMovePropertyId,                     // 30087
    UIA_TransformCanResizePropertyId,                   // 30088
    UIA_TransformCanRotatePropertyId,                   // 30089
    UIA_IsLegacyIAccessiblePatternAvailablePropertyId,  // 30090
    // UIA_LegacyIAccessible*                           // 30091-30100
    UIA_AriaRolePropertyId,                             // 30101
    UIA_AriaPropertiesPropertyId,                       // 30102
    UIA_IsDataValidForFormPropertyId,                   // 30103
    UIA_ControllerForPropertyId,                        // 30104
    UIA_DescribedByPropertyId,                          // 30105
    UIA_FlowsToPropertyId,                              // 30106
    // UIA_ProviderDescriptionPropertyId                // 30107
    UIA_IsItemContainerPatternAvailablePropertyId,      // 30108
    UIA_IsVirtualizedItemPatternAvailablePropertyId,    // 30109
    UIA_IsSynchronizedInputPatternAvailablePropertyId,  // 30110
    UIA_OptimizeForVisualContentPropertyId,             // 30111
    UIA_IsObjectModelPatternAvailablePropertyId,        // 30112
    UIA_AnnotationAnnotationTypeIdPropertyId,           // 30113
    UIA_AnnotationAnnotationTypeNamePropertyId,         // 30114
    UIA_AnnotationAuthorPropertyId,                     // 30115
    UIA_AnnotationDateTimePropertyId,                   // 30116
    UIA_AnnotationTargetPropertyId,                     // 30117
    UIA_IsAnnotationPatternAvailablePropertyId,         // 30118
    UIA_IsTextPattern2AvailablePropertyId,              // 30119
    UIA_StylesStyleIdPropertyId,                        // 30120
    UIA_StylesStyleNamePropertyId,                      // 30121
    UIA_StylesFillColorPropertyId,                      // 30122
    UIA_StylesFillPatternStylePropertyId,               // 30123
    UIA_StylesShapePropertyId,                          // 30124
    UIA_StylesFillPatternColorPropertyId,               // 30125
    UIA_StylesExtendedPropertiesPropertyId,             // 30126
    UIA_IsStylesPatternAvailablePropertyId,             // 30127
    UIA_IsSpreadsheetPatternAvailablePropertyId,        // 30128
    UIA_SpreadsheetItemFormulaPropertyId,               // 30129
    UIA_SpreadsheetItemAnnotationObjectsPropertyId,     // 30130
    UIA_SpreadsheetItemAnnotationTypesPropertyId,       // 30131
    UIA_IsSpreadsheetItemPatternAvailablePropertyId,    // 30132
    UIA_Transform2CanZoomPropertyId,                    // 30133
    UIA_IsTransformPattern2AvailablePropertyId,         // 30134
    UIA_LiveSettingPropertyId,                          // 30135
    UIA_IsTextChildPatternAvailablePropertyId,          // 30136
    UIA_IsDragPatternAvailablePropertyId,               // 30137
    UIA_DragIsGrabbedPropertyId,                        // 30138
    UIA_DragDropEffectPropertyId,                       // 30139
    UIA_DragDropEffectsPropertyId,                      // 30140
    UIA_IsDropTargetPatternAvailablePropertyId,         // 30141
    UIA_DropTargetDropTargetEffectPropertyId,           // 30142
    UIA_DropTargetDropTargetEffectsPropertyId,          // 30143
    UIA_DragGrabbedItemsPropertyId,                     // 30144
    UIA_Transform2ZoomLevelPropertyId,                  // 30145
    UIA_Transform2ZoomMinimumPropertyId,                // 30146
    UIA_Transform2ZoomMaximumPropertyId,                // 30147
    UIA_FlowsFromPropertyId,                            // 30148
    UIA_IsTextEditPatternAvailablePropertyId,           // 30149
    UIA_IsPeripheralPropertyId,                         // 30150
    UIA_IsCustomNavigationPatternAvailablePropertyId,   // 30151
    UIA_PositionInSetPropertyId,                        // 30152
    UIA_SizeOfSetPropertyId,                            // 30153
    UIA_LevelPropertyId,                                // 30154
    UIA_AnnotationTypesPropertyId,                      // 30155
    UIA_AnnotationObjectsPropertyId,                    // 30156
    UIA_LandmarkTypePropertyId,                         // 30157
    UIA_LocalizedLandmarkTypePropertyId,                // 30158
    UIA_FullDescriptionPropertyId,                      // 30159
    UIA_FillColorPropertyId,                            // 30160
    UIA_OutlineColorPropertyId,                         // 30161
    UIA_FillTypePropertyId,                             // 30162
    UIA_VisualEffectsPropertyId,                        // 30163
    UIA_OutlineThicknessPropertyId,                     // 30164
    UIA_CenterPointPropertyId,                          // 30165
    UIA_RotationPropertyId,                             // 30166
    UIA_SizePropertyId,                                 // 30167
    UIA_IsSelectionPattern2AvailablePropertyId,         // 30168
    UIA_Selection2FirstSelectedItemPropertyId,          // 30169
    UIA_Selection2LastSelectedItemPropertyId,           // 30170
    UIA_Selection2CurrentSelectedItemPropertyId,        // 30171
    UIA_Selection2ItemCountPropertyId,                  // 30172
    UIA_HeadingLevelPropertyId,                         // 30173
};

// static
std::unique_ptr<AccessibilityTreeFormatter>
AccessibilityTreeFormatterUia::CreateUia() {
  base::win::AssertComInitialized();
  return std::make_unique<AccessibilityTreeFormatterUia>();
}

AccessibilityTreeFormatterUia::AccessibilityTreeFormatterUia() {
  // Create an instance of the CUIAutomation class.
  CoCreateInstance(CLSID_CUIAutomation, NULL, CLSCTX_INPROC_SERVER,
                   IID_IUIAutomation, &uia_);
  CHECK(uia_.Get());
  BuildCacheRequests();
}

AccessibilityTreeFormatterUia::~AccessibilityTreeFormatterUia() {}

void AccessibilityTreeFormatterUia::AddDefaultFilters(
    std::vector<PropertyFilter>* property_filters) {
  AddPropertyFilter(property_filters, "Name=*");
  AddPropertyFilter(property_filters, "ItemStatus=*");
  AddPropertyFilter(property_filters, "IsKeyboardFocusable=true");
  AddPropertyFilter(property_filters, "Orientation=OrientationType_Horizontal");
  AddPropertyFilter(property_filters, "IsPassword=true");
  AddPropertyFilter(property_filters, "IsControlElement=false");
  AddPropertyFilter(property_filters, "IsEnabled=false");
  AddPropertyFilter(property_filters, "IsDataValidForForm=true");
  AddPropertyFilter(property_filters, "IsRequiredForForm=true");
}

// static
void AccessibilityTreeFormatterUia::SetUpCommandLineForTestPass(
    base::CommandLine* command_line) {
  command_line->AppendSwitch(::switches::kEnableExperimentalUIAutomation);
}

std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterUia::BuildAccessibilityTree(
    BrowserAccessibility* start) {
  // Find the root IUIAutomationElement for the content window.
  HWND hwnd =
      start->manager()->GetRoot()->GetTargetForNativeAccessibilityEvent();
  return BuildAccessibilityTreeForWindow(hwnd);
}

std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterUia::BuildAccessibilityTreeForProcess(
    base::ProcessId pid) {
  std::unique_ptr<base::DictionaryValue> tree;
  // Get HWND for process id.
  HWND hwnd = GetHwndForProcess(pid);
  return BuildAccessibilityTreeForWindow(hwnd);
}

std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterUia::BuildAccessibilityTreeForWindow(
    gfx::AcceleratedWidget hwnd) {
  CHECK(hwnd);

  Microsoft::WRL::ComPtr<IUIAutomationElement> root;
  uia_->ElementFromHandle(hwnd, &root);
  CHECK(root.Get());

  std::unique_ptr<base::DictionaryValue> tree =
      std::make_unique<base::DictionaryValue>();
  RecursiveBuildAccessibilityTree(root.Get(), tree.get());
  return tree;
}

std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterUia::BuildAccessibilityTreeForPattern(
    const base::StringPiece& pattern) {
  LOG(ERROR) << "Windows does not yet support building accessibility trees for "
                "patterns";
  return nullptr;
}

void AccessibilityTreeFormatterUia::RecursiveBuildAccessibilityTree(
    IUIAutomationElement* uncached_node,
    base::DictionaryValue* dict) {
  // Process this node.
  AddProperties(uncached_node, dict);

  // Update the cache to get children
  Microsoft::WRL::ComPtr<IUIAutomationElement> parent;
  uncached_node->BuildUpdatedCache(children_cache_request_.Get(), &parent);

  Microsoft::WRL::ComPtr<IUIAutomationElementArray> children;
  if (!SUCCEEDED(parent->GetCachedChildren(&children)) || !children)
    return;
  // Process children.
  auto child_list = std::make_unique<base::ListValue>();
  int child_count;
  children->get_Length(&child_count);
  for (int i = 0; i < child_count; i++) {
    Microsoft::WRL::ComPtr<IUIAutomationElement> child;
    std::unique_ptr<base::DictionaryValue> child_dict =
        std::make_unique<base::DictionaryValue>();
    if (SUCCEEDED(children->GetElement(i, &child))) {
      RecursiveBuildAccessibilityTree(child.Get(), child_dict.get());
    } else {
      child_dict->SetString("error", L"[Error retrieving child]");
    }
    child_list->Append(std::move(child_dict));
  }
  dict->Set(kChildrenDictAttr, std::move(child_list));
}

void AccessibilityTreeFormatterUia::AddProperties(
    IUIAutomationElement* uncached_node,
    base::DictionaryValue* dict) {
  // Update the cache for this node's information.
  Microsoft::WRL::ComPtr<IUIAutomationElement> node;
  uncached_node->BuildUpdatedCache(element_cache_request_.Get(), &node);

  // Get all properties that may be on this node.
  for (long i : properties_) {
    base::win::ScopedVariant variant;
    if (SUCCEEDED(node->GetCachedPropertyValue(i, variant.Receive()))) {
      WriteProperty(i, variant, dict);
    }
  }
}

void AccessibilityTreeFormatterUia::WriteProperty(
    long propertyId,
    const base::win::ScopedVariant& var,
    base::DictionaryValue* dict) {
  switch (var.type()) {
    case VT_EMPTY:
    case VT_NULL:
      break;
    case VT_I2:
      dict->SetInteger(UiaIdentifierToCondensedString(propertyId),
                       var.ptr()->iVal);
      break;
    case VT_I4:
      WriteI4Property(propertyId, var.ptr()->lVal, dict);
      break;
    case VT_R4:
      dict->SetDouble(UiaIdentifierToCondensedString(propertyId),
                      var.ptr()->fltVal);
      break;
    case VT_R8:
      dict->SetDouble(UiaIdentifierToCondensedString(propertyId),
                      var.ptr()->dblVal);
      break;
    case VT_I1:
      dict->SetInteger(UiaIdentifierToCondensedString(propertyId),
                       var.ptr()->cVal);
      break;
    case VT_UI1:
      dict->SetInteger(UiaIdentifierToCondensedString(propertyId),
                       var.ptr()->bVal);
      break;
    case VT_UI2:
      dict->SetInteger(UiaIdentifierToCondensedString(propertyId),
                       var.ptr()->uiVal);
      break;
    case VT_UI4:
      dict->SetInteger(UiaIdentifierToCondensedString(propertyId),
                       var.ptr()->ulVal);
      break;
      break;
    case VT_BSTR:
      dict->SetString(UiaIdentifierToCondensedString(propertyId),
                      BstrToUTF8(var.ptr()->bstrVal));
      break;
    case VT_BOOL:
      dict->SetBoolean(UiaIdentifierToCondensedString(propertyId),
                       var.ptr()->boolVal == VARIANT_TRUE ? true : false);
      break;
    case VT_UNKNOWN:
      WriteUnknownProperty(propertyId, var.ptr()->punkVal, dict);
      break;
    case VT_DISPATCH:
    case VT_ERROR:
    case VT_CY:
    case VT_DATE:
    case VT_VARIANT:
    case VT_DECIMAL:
    case VT_INT:
    case VT_UINT:
    case VT_ARRAY:
    case VT_BYREF:
    default:
      break;
  }
}

void AccessibilityTreeFormatterUia::WriteI4Property(
    long propertyId,
    long lval,
    base::DictionaryValue* dict) {
  switch (propertyId) {
    case UIA_ControlTypePropertyId:
      dict->SetString(UiaIdentifierToCondensedString(propertyId),
                      UiaIdentifierToCondensedString16(lval));
      break;
    case UIA_OrientationPropertyId:
      dict->SetString(UiaIdentifierToCondensedString(propertyId),
                      UiaOrientationToString(lval));
      break;
    case UIA_LiveSettingPropertyId:
      dict->SetString(UiaIdentifierToCondensedString(propertyId),
                      UiaLiveSettingToString(lval));
      break;
    default:
      dict->SetInteger(UiaIdentifierToCondensedString(propertyId), lval);
      break;
  }
}

void AccessibilityTreeFormatterUia::WriteUnknownProperty(
    long propertyId,
    IUnknown* unk,
    base::DictionaryValue* dict) {
  switch (propertyId) {
    case UIA_ControllerForPropertyId:
    case UIA_DescribedByPropertyId:
    case UIA_FlowsFromPropertyId:
    case UIA_FlowsToPropertyId: {
      Microsoft::WRL::ComPtr<IUIAutomationElementArray> array;
      if (unk && SUCCEEDED(unk->QueryInterface(IID_PPV_ARGS(&array))))
        WriteElementArray(propertyId, array.Get(), dict);
      break;
    }
    case UIA_LabeledByPropertyId: {
      Microsoft::WRL::ComPtr<IUIAutomationElement> node;
      if (unk && SUCCEEDED(unk->QueryInterface(IID_PPV_ARGS(&node)))) {
        dict->SetString(UiaIdentifierToCondensedString(propertyId),
                        GetNodeName(node.Get()));
      }
      break;
    }
    default:
      break;
  }
}

void AccessibilityTreeFormatterUia::WriteElementArray(
    long propertyId,
    IUIAutomationElementArray* array,
    base::DictionaryValue* dict) {
  int count;
  array->get_Length(&count);
  base::string16 element_list = L"";
  for (int i = 0; i < count; i++) {
    Microsoft::WRL::ComPtr<IUIAutomationElement> element;
    if (SUCCEEDED(array->GetElement(i, &element))) {
      if (element_list != L"") {
        element_list += L", ";
      }
      element_list += GetNodeName(element.Get());
    }
  }
  dict->SetString(UiaIdentifierToCondensedString(propertyId), element_list);
}

base::string16 AccessibilityTreeFormatterUia::GetNodeName(
    IUIAutomationElement* uncached_node) {
  // Update the cache for this node.
  Microsoft::WRL::ComPtr<IUIAutomationElement> node;
  uncached_node->BuildUpdatedCache(element_cache_request_.Get(), &node);

  base::win::ScopedBstr name;
  base::win::ScopedVariant variant;
  if (SUCCEEDED(node->GetCachedPropertyValue(UIA_NamePropertyId,
                                             variant.Receive())) &&
      variant.type() == VT_BSTR) {
    return base::string16(variant.ptr()->bstrVal,
                          SysStringLen(variant.ptr()->bstrVal));
  }
  return L"";
}

void AccessibilityTreeFormatterUia::BuildCacheRequests() {
  // Create cache request for requesting children of a node.
  uia_->CreateCacheRequest(&children_cache_request_);
  CHECK(children_cache_request_.Get());
  children_cache_request_->put_TreeScope(TreeScope_Children);

  // Create cache request for requesting information about a node.
  uia_->CreateCacheRequest(&element_cache_request_);
  CHECK(element_cache_request_.Get());
  element_cache_request_->put_TreeScope(TreeScope_Element);

  // Caching properties allows us to use GetCachedPropertyValue.
  // The non-cached version (GetCurrentPropertyValue) may cross
  // the process boundary for each call.

  // Cache all properties.
  for (long i : properties_) {
    element_cache_request_->AddProperty(i);
  }
}

base::string16 AccessibilityTreeFormatterUia::ProcessTreeForOutput(
    const base::DictionaryValue& dict,
    base::DictionaryValue* filtered_dict_result) {
  std::unique_ptr<base::DictionaryValue> tree;
  base::string16 line;

  // Always show role, and show it first.
  base::string16 role_value;
  dict.GetString(UiaIdentifierToCondensedString(UIA_AriaRolePropertyId),
                 &role_value);
  WriteAttribute(true, base::UTF16ToUTF8(role_value), &line);
  if (filtered_dict_result) {
    filtered_dict_result->SetString(
        UiaIdentifierToStringUTF8(UIA_AriaRolePropertyId), role_value);
  }

  for (long i : properties_) {
    const std::string attribute_name = UiaIdentifierToCondensedString(i);
    const base::Value* value;
    if (!dict.Get(attribute_name, &value))
      continue;
    switch (value->type()) {
      case base::Value::Type::STRING: {
        base::string16 string_value;
        value->GetAsString(&string_value);
        bool did_pass_filters = WriteAttribute(
            false,
            base::StringPrintf(L"%ls='%ls'",
                               base::UTF8ToUTF16(attribute_name).c_str(),
                               string_value.c_str()),
            &line);
        if (filtered_dict_result && did_pass_filters)
          filtered_dict_result->SetString(attribute_name, string_value);
        break;
      }
      case base::Value::Type::BOOLEAN: {
        bool bool_value = 0;
        value->GetAsBoolean(&bool_value);
        bool did_pass_filters = WriteAttribute(
            false,
            base::StringPrintf(L"%ls=%ls",
                               base::UTF8ToUTF16(attribute_name).c_str(),
                               (bool_value ? L"true" : L"false")),
            &line);
        if (filtered_dict_result && did_pass_filters)
          filtered_dict_result->SetBoolean(attribute_name, bool_value);
        break;
      }
      case base::Value::Type::INTEGER: {
        int int_value = 0;
        value->GetAsInteger(&int_value);
        bool did_pass_filters = WriteAttribute(
            false,
            base::StringPrintf(L"%ls=%d",
                               base::UTF8ToUTF16(attribute_name).c_str(),
                               int_value),
            &line);
        if (filtered_dict_result && did_pass_filters)
          filtered_dict_result->SetInteger(attribute_name, int_value);
        break;
      }
      case base::Value::Type::DOUBLE: {
        double double_value = 0.0;
        value->GetAsDouble(&double_value);
        bool did_pass_filters = WriteAttribute(
            false,
            base::StringPrintf(L"%ls=%.2f",
                               base::UTF8ToUTF16(attribute_name).c_str(),
                               double_value),
            &line);
        if (filtered_dict_result && did_pass_filters)
          filtered_dict_result->SetDouble(attribute_name, double_value);
        break;
      }
      default:
        NOTREACHED();
        break;
    }
  }
  return line;
}

const base::FilePath::StringType
AccessibilityTreeFormatterUia::GetExpectedFileSuffix() {
  return FILE_PATH_LITERAL("-expected-uia-win.txt");
}

const base::FilePath::StringType
AccessibilityTreeFormatterUia::GetVersionSpecificExpectedFileSuffix() {
  if (base::win::GetVersion() == base::win::Version::VERSION_WIN7) {
    return FILE_PATH_LITERAL("-expected-uia-win7.txt");
  }
  return FILE_PATH_LITERAL("");
}

const std::string AccessibilityTreeFormatterUia::GetAllowEmptyString() {
  return "@UIA-WIN-ALLOW-EMPTY:";
}

const std::string AccessibilityTreeFormatterUia::GetAllowString() {
  return "@UIA-WIN-ALLOW:";
}

const std::string AccessibilityTreeFormatterUia::GetDenyString() {
  return "@UIA-WIN-DENY:";
}

const std::string AccessibilityTreeFormatterUia::GetDenyNodeString() {
  return "@UIA-WIN-DENY-NODE:";
}

}  // namespace content