Better handle null delegates by returning instead of CHECK()

ui/accessibility/platform/ax_platform_node_base.cc

 // Copyright 2014 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 "ui/accessibility/platform/ax_platform_node_base.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "ui/accessibility/ax_action_data.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/accessibility/ax_role_properties.h"
 #include "ui/accessibility/platform/ax_platform_node_delegate.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace ui {
 
 void AXPlatformNodeBase::Init(AXPlatformNodeDelegate* delegate) {
   delegate_ = delegate;
 }
 
 const AXNodeData& AXPlatformNodeBase::GetData() const {
-  CHECK(delegate_);
-  return delegate_->GetData();
+  CR_DEFINE_STATIC_LOCAL(ui::AXNodeData, empty_data, ());
+  if (delegate_)
+    return delegate_->GetData();
+  return empty_data;
 }
 
 gfx::Rect AXPlatformNodeBase::GetBoundsInScreen() const {
-  CHECK(delegate_);
-  return delegate_->GetScreenBoundsRect();
+  if (delegate_)
+    return delegate_->GetScreenBoundsRect();
+  return gfx::Rect();
 }
 
 gfx::NativeViewAccessible AXPlatformNodeBase::GetParent() {
-  CHECK(delegate_);
-  return delegate_->GetParent();
+  if (delegate_)
+    return delegate_->GetParent();
+  return nullptr;
 }
 
 int AXPlatformNodeBase::GetChildCount() {
-  CHECK(delegate_);
-  return delegate_->GetChildCount();
+  if (delegate_)
+    return delegate_->GetChildCount();
+  return 0;
 }
 
 gfx::NativeViewAccessible AXPlatformNodeBase::ChildAtIndex(int index) {
-  CHECK(delegate_);
-  return delegate_->ChildAtIndex(index);
+  if (delegate_)
+    return delegate_->ChildAtIndex(index);
+  return nullptr;
 }
 
 // AXPlatformNode overrides.
 
 void AXPlatformNodeBase::Destroy() {
   AXPlatformNode::Destroy();
   delegate_ = nullptr;
   Dispose();
 }
 
 void AXPlatformNodeBase::Dispose() {
   delete this;
 }
 
 gfx::NativeViewAccessible AXPlatformNodeBase::GetNativeViewAccessible() {
   return nullptr;
 }
 
 AXPlatformNodeDelegate* AXPlatformNodeBase::GetDelegate() const {
   return delegate_;
 }
 
 // Helpers.
 
 AXPlatformNodeBase* AXPlatformNodeBase::GetPreviousSibling() {
-  CHECK(delegate_);
+  if (!delegate_)
+    return nullptr;
   gfx::NativeViewAccessible parent_accessible = GetParent();
   AXPlatformNodeBase* parent = FromNativeViewAccessible(parent_accessible);
   if (!parent)
     return nullptr;
 
   int previous_index = GetIndexInParent() - 1;
   if (previous_index >= 0 &&
       previous_index < parent->GetChildCount()) {
     return FromNativeViewAccessible(parent->ChildAtIndex(previous_index));
   }
   return nullptr;
 }
 
 AXPlatformNodeBase* AXPlatformNodeBase::GetNextSibling() {
-  CHECK(delegate_);
+  if (!delegate_)
+    return nullptr;
   gfx::NativeViewAccessible parent_accessible = GetParent();
   AXPlatformNodeBase* parent = FromNativeViewAccessible(parent_accessible);
   if (!parent)
     return nullptr;
 
   int next_index = GetIndexInParent() + 1;
   if (next_index >= 0 && next_index < parent->GetChildCount())
     return FromNativeViewAccessible(parent->ChildAtIndex(next_index));
   return nullptr;
 }
 
 bool AXPlatformNodeBase::IsDescendant(AXPlatformNodeBase* node) {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   if (!node)
     return false;
   if (node == this)
     return true;
   gfx::NativeViewAccessible native_parent = node->GetParent();
   if (!native_parent)
     return false;
   AXPlatformNodeBase* parent = FromNativeViewAccessible(native_parent);
   return IsDescendant(parent);
 }
 
 bool AXPlatformNodeBase::HasBoolAttribute(
     ui::AXBoolAttribute attribute) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().HasBoolAttribute(attribute);
 }
 
 bool AXPlatformNodeBase::GetBoolAttribute(
     ui::AXBoolAttribute attribute) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().GetBoolAttribute(attribute);
 }
 
 bool AXPlatformNodeBase::GetBoolAttribute(
     ui::AXBoolAttribute attribute, bool* value) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().GetBoolAttribute(attribute, value);
 }
 
 bool AXPlatformNodeBase::HasFloatAttribute(
     ui::AXFloatAttribute attribute) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().HasFloatAttribute(attribute);
 }
 
 float AXPlatformNodeBase::GetFloatAttribute(
     ui::AXFloatAttribute attribute) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().GetFloatAttribute(attribute);
 }
 
 bool AXPlatformNodeBase::GetFloatAttribute(
     ui::AXFloatAttribute attribute, float* value) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().GetFloatAttribute(attribute, value);
 }
 
 bool AXPlatformNodeBase::HasIntAttribute(
     ui::AXIntAttribute attribute) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().HasIntAttribute(attribute);
 }
 
 int AXPlatformNodeBase::GetIntAttribute(
     ui::AXIntAttribute attribute) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().GetIntAttribute(attribute);
 }
 
 bool AXPlatformNodeBase::GetIntAttribute(
     ui::AXIntAttribute attribute, int* value) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().GetIntAttribute(attribute, value);
 }
 
 bool AXPlatformNodeBase::HasStringAttribute(
     ui::AXStringAttribute attribute) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().HasStringAttribute(attribute);
 }
 
 const std::string& AXPlatformNodeBase::GetStringAttribute(
     ui::AXStringAttribute attribute) const {
-  CHECK(delegate_);
+  CR_DEFINE_STATIC_LOCAL(std::string, empty_data, ());
+  if (!delegate_)
+    return empty_data;
   return GetData().GetStringAttribute(attribute);
 }
 
 bool AXPlatformNodeBase::GetStringAttribute(
     ui::AXStringAttribute attribute, std::string* value) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().GetStringAttribute(attribute, value);
 }
 
 base::string16 AXPlatformNodeBase::GetString16Attribute(
     ui::AXStringAttribute attribute) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return base::string16();
   return GetData().GetString16Attribute(attribute);
 }
 
 bool AXPlatformNodeBase::GetString16Attribute(
     ui::AXStringAttribute attribute,
     base::string16* value) const {
-  CHECK(delegate_);
+  if (!delegate_)
+    return false;
   return GetData().GetString16Attribute(attribute, value);
 }
 
 bool AXPlatformNodeBase::HasIntListAttribute(
     ui::AXIntListAttribute attribute) const {
+  if (!delegate_)
+    return false;
   return GetData().HasIntListAttribute(attribute);
 }
 
 const std::vector<int32_t>& AXPlatformNodeBase::GetIntListAttribute(
     ui::AXIntListAttribute attribute) const {
+  CR_DEFINE_STATIC_LOCAL(std::vector<int32_t>, empty_data, ());
+  if (!delegate_)
+    return empty_data;
   return GetData().GetIntListAttribute(attribute);
 }
 
 bool AXPlatformNodeBase::GetIntListAttribute(
     ui::AXIntListAttribute attribute,
     std::vector<int32_t>* value) const {
+  if (!delegate_)
+    return false;
   return GetData().GetIntListAttribute(attribute, value);
 }
 
 AXPlatformNodeBase::AXPlatformNodeBase() {
 }
 
 AXPlatformNodeBase::~AXPlatformNodeBase() {
-  CHECK(!delegate_);
 }
 
 // static
 AXPlatformNodeBase* AXPlatformNodeBase::FromNativeViewAccessible(
     gfx::NativeViewAccessible accessible) {
   return static_cast<AXPlatformNodeBase*>(
       AXPlatformNode::FromNativeViewAccessible(accessible));
 }
 
 bool AXPlatformNodeBase::SetTextSelection(int start_offset, int end_offset) {
   ui::AXActionData action_data;
   action_data.action = ui::AX_ACTION_SET_SELECTION;
   action_data.anchor_node_id = action_data.focus_node_id = GetData().id;
   action_data.anchor_offset = start_offset;
   action_data.focus_offset = end_offset;
-  DCHECK(delegate_);
+  if (!delegate_)
+    return false;
+
   return delegate_->AccessibilityPerformAction(action_data);
 }
 
 bool AXPlatformNodeBase::IsTextOnlyObject() const {
   return GetData().role == ui::AX_ROLE_STATIC_TEXT ||
          GetData().role == ui::AX_ROLE_LINE_BREAK ||
          GetData().role == ui::AX_ROLE_INLINE_TEXT_BOX;
 }
 
 bool AXPlatformNodeBase::IsNativeTextControl() const {
@@ skipping 59 matching lines @@
     case ui::AX_ROLE_SCROLL_BAR:
       return true;
     case ui::AX_ROLE_SPLITTER:
       return GetData().HasState(ui::AX_STATE_FOCUSABLE);
     default:
       return false;
   }
 }
 
 AXPlatformNodeBase* AXPlatformNodeBase::GetTable() const {
+  if (!delegate_)
+    return nullptr;
   AXPlatformNodeBase* table = const_cast<AXPlatformNodeBase*>(this);
   while (table && !ui::IsTableLikeRole(table->GetData().role)) {
     gfx::NativeViewAccessible parent_accessible = table->GetParent();
     AXPlatformNodeBase* parent = FromNativeViewAccessible(parent_accessible);
 
     table = parent;
   }
   return table;
 }
 
 AXPlatformNodeBase* AXPlatformNodeBase::GetTableCell(int index) const {
-  DCHECK(delegate_);
-
+  if (!delegate_)
+    return nullptr;
   if (!ui::IsTableLikeRole(GetData().role) &&
       !ui::IsCellOrTableHeaderRole(GetData().role))
     return nullptr;
 
   AXPlatformNodeBase* table = GetTable();
   if (!table)
     return nullptr;
   const std::vector<int32_t>& unique_cell_ids =
       table->GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   if (index < 0 || index >= static_cast<int>(unique_cell_ids.size()))
@@ skipping 88 matching lines @@
   if (!ui::IsCellOrTableHeaderRole(GetData().role))
     return 0;
 
   int row_span;
   if (GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &row_span))
     return row_span;
   return 1;
 }
 
 }  // namespace ui