[C++11 Allowed Features] Declares a type-safe null pointer converting from NULL to nullptr

content/browser/accessibility/browser_accessibility_manager.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 "content/browser/accessibility/browser_accessibility_manager.h"
 
 #include "base/logging.h"
 #include "content/browser/accessibility/browser_accessibility.h"
 #include "content/common/accessibility_messages.h"
 #include "ui/accessibility/ax_tree_serializer.h"
@@ skipping 51 matching lines @@
   return new BrowserAccessibilityManager(initial_tree, delegate, factory);
 }
 #endif
 
 BrowserAccessibilityManager::BrowserAccessibilityManager(
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory)
     : delegate_(delegate),
       factory_(factory),
       tree_(new ui::AXSerializableTree()),
-      focus_(NULL),
+      focus_(nullptr),
       osk_state_(OSK_ALLOWED) {
   tree_->SetDelegate(this);
 }
 
 BrowserAccessibilityManager::BrowserAccessibilityManager(
     const ui::AXTreeUpdate& initial_tree,
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory)
     : delegate_(delegate),
       factory_(factory),
       tree_(new ui::AXSerializableTree()),
-      focus_(NULL),
+      focus_(nullptr),
       osk_state_(OSK_ALLOWED) {
   tree_->SetDelegate(this);
   Initialize(initial_tree);
 }
 
 BrowserAccessibilityManager::~BrowserAccessibilityManager() {
-  tree_.reset(NULL);
+  tree_.reset(nullptr);
 }
 
 void BrowserAccessibilityManager::Initialize(
     const ui::AXTreeUpdate& initial_tree) {
   if (!tree_->Unserialize(initial_tree)) {
     if (delegate_) {
       LOG(ERROR) << tree_->error();
       delegate_->AccessibilityFatalError();
     } else {
       LOG(FATAL) << tree_->error();
@@ skipping 21 matching lines @@
 BrowserAccessibility* BrowserAccessibilityManager::GetFromAXNode(
     ui::AXNode* node) {
   return GetFromID(node->id());
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetFromID(int32 id) {
   base::hash_map<int32, BrowserAccessibility*>::iterator iter =
       id_wrapper_map_.find(id);
   if (iter != id_wrapper_map_.end())
     return iter->second;
-  return NULL;
+  return nullptr;
 }
 
 void BrowserAccessibilityManager::OnWindowFocused() {
   if (focus_)
     NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, GetFromAXNode(focus_));
 }
 
 void BrowserAccessibilityManager::OnWindowBlurred() {
   if (focus_)
     NotifyAccessibilityEvent(ui::AX_EVENT_BLUR, GetFromAXNode(focus_));
@@ skipping 78 matching lines @@
     ui::AXNode* node = obj->node();
     node->SetLocation(params[i].new_location);
     obj->OnLocationChanged();
   }
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetActiveDescendantFocus(
     BrowserAccessibility* root) {
   BrowserAccessibility* node = BrowserAccessibilityManager::GetFocus(root);
   if (!node)
-    return NULL;
+    return nullptr;
 
   int active_descendant_id;
   if (node->GetIntAttribute(ui::AX_ATTR_ACTIVEDESCENDANT_ID,
                             &active_descendant_id)) {
     BrowserAccessibility* active_descendant =
         node->manager()->GetFromID(active_descendant_id);
     if (active_descendant)
       return active_descendant;
   }
   return node;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetFocus(
     BrowserAccessibility* root) {
   if (focus_ && (!root || focus_->IsDescendantOf(root->node())))
     return GetFromAXNode(focus_);
 
-  return NULL;
+  return nullptr;
 }
 
 void BrowserAccessibilityManager::SetFocus(ui::AXNode* node, bool notify) {
   if (focus_ != node)
     focus_ = node;
 
   if (notify && node && delegate_)
     delegate_->AccessibilitySetFocus(node->id());
 }
 
@@ skipping 33 matching lines @@
 
 gfx::Rect BrowserAccessibilityManager::GetViewBounds() {
   if (delegate_)
     return delegate_->AccessibilityGetViewBounds();
   return gfx::Rect();
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::NextInTreeOrder(
     BrowserAccessibility* node) {
   if (!node)
-    return NULL;
+    return nullptr;
 
   if (node->PlatformChildCount() > 0)
     return node->PlatformGetChild(0);
   while (node) {
     if (node->GetParent() &&
         node->GetIndexInParent() <
             static_cast<int>(node->GetParent()->PlatformChildCount()) - 1) {
       return node->GetParent()->PlatformGetChild(node->GetIndexInParent() + 1);
     }
     node = node->GetParent();
   }
 
-  return NULL;
+  return nullptr;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::PreviousInTreeOrder(
     BrowserAccessibility* node) {
   if (!node)
-    return NULL;
+    return nullptr;
 
   if (node->GetParent() && node->GetIndexInParent() > 0) {
     node = node->GetParent()->PlatformGetChild(node->GetIndexInParent() - 1);
     while (node->PlatformChildCount() > 0)
       node = node->PlatformGetChild(node->PlatformChildCount() - 1);
     return node;
   }
 
   return node->GetParent();
 }
 
 void BrowserAccessibilityManager::OnNodeWillBeDeleted(ui::AXNode* node) {
   if (node == focus_ && tree_) {
     if (node != tree_->GetRoot())
       SetFocus(tree_->GetRoot(), false);
     else
-      focus_ = NULL;
+      focus_ = nullptr;
   }
   if (id_wrapper_map_.find(node->id()) == id_wrapper_map_.end())
     return;
   GetFromAXNode(node)->Destroy();
   id_wrapper_map_.erase(node->id());
 }
 
 void BrowserAccessibilityManager::OnNodeCreated(ui::AXNode* node) {
   BrowserAccessibility* wrapper = factory_->Create();
   wrapper->Init(this, node);
@@ skipping 16 matching lines @@
 ui::AXTreeUpdate BrowserAccessibilityManager::SnapshotAXTreeForTesting() {
   scoped_ptr<ui::AXTreeSource<const ui::AXNode*> > tree_source(
       tree_->CreateTreeSource());
   ui::AXTreeSerializer<const ui::AXNode*> serializer(tree_source.get());
   ui::AXTreeUpdate update;
   serializer.SerializeChanges(tree_->GetRoot(), &update);
   return update;
 }
 
 }  // namespace content