DevTools: expose raw pointers in protocol collections, s/ASSERT/DCHECK/.

third_party/WebKit/Source/platform/inspector_protocol/Values.cpp

 // Copyright 2016 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 "platform/inspector_protocol/Values.h"
 
 #include "platform/inspector_protocol/Parser.h"
 #include "platform/inspector_protocol/String16.h"
 #include <cmath>
 
@@ skipping 82 matching lines @@
 String16 Value::toJSONString() const
 {
     String16Builder result;
     result.reserveCapacity(512);
     writeJSON(&result);
     return result.toString();
 }
 
 void Value::writeJSON(String16Builder* output) const
 {
-    ASSERT(m_type == TypeNull);
+    DCHECK(m_type == TypeNull);
     output->append(nullString, 4);
 }
 
 PassOwnPtr<Value> Value::clone() const
 {
     return Value::null();
 }
 
 bool FundamentalValue::asBoolean(bool* output) const
 {
@@ skipping 14 matching lines @@
 bool FundamentalValue::asNumber(int* output) const
 {
     if (type() != TypeNumber)
         return false;
     *output = static_cast<int>(m_doubleValue);
     return true;
 }
 
 void FundamentalValue::writeJSON(String16Builder* output) const
 {
-    ASSERT(type() == TypeBoolean || type() == TypeNumber);
+    DCHECK(type() == TypeBoolean || type() == TypeNumber);
     if (type() == TypeBoolean) {
         if (m_boolValue)
             output->append(trueString, 4);
         else
             output->append(falseString, 5);
     } else if (type() == TypeNumber) {
         if (!std::isfinite(m_doubleValue)) {
             output->append(nullString, 4);
             return;
         }
         output->append(String16::fromDouble(m_doubleValue));
     }
 }
 
 PassOwnPtr<Value> FundamentalValue::clone() const
 {
     return type() == TypeNumber ? FundamentalValue::create(m_doubleValue) : FundamentalValue::create(m_boolValue);
 }
 
 bool StringValue::asString(String16* output) const
 {
     *output = m_stringValue;
     return true;
 }
 
 void StringValue::writeJSON(String16Builder* output) const
 {
-    ASSERT(type() == TypeString);
+    DCHECK(type() == TypeString);
     doubleQuoteStringForJSON(m_stringValue, output);
 }
 
 PassOwnPtr<Value> StringValue::clone() const
 {
     return StringValue::create(m_stringValue);
 }
 
 DictionaryValue::~DictionaryValue()
 {
 }
 
 void DictionaryValue::setBoolean(const String16& name, bool value)
 {
     setValue(name, FundamentalValue::create(value));
 }
 
 void DictionaryValue::setNumber(const String16& name, double value)
 {
     setValue(name, FundamentalValue::create(value));
 }
 
 void DictionaryValue::setString(const String16& name, const String16& value)
 {
     setValue(name, StringValue::create(value));
 }
 
 void DictionaryValue::setValue(const String16& name, PassOwnPtr<Value> value)
 {
-    ASSERT(value);
+    DCHECK(value);
     if (m_data.set(name, std::move(value)))
         m_order.append(name);
 }
 
 void DictionaryValue::setObject(const String16& name, PassOwnPtr<DictionaryValue> value)
 {
-    ASSERT(value);
+    DCHECK(value);
     if (m_data.set(name, std::move(value)))
         m_order.append(name);
 }
 
 void DictionaryValue::setArray(const String16& name, PassOwnPtr<ListValue> value)
 {
-    ASSERT(value);
+    DCHECK(value);
     if (m_data.set(name, std::move(value)))
         m_order.append(name);
 }
 
 bool DictionaryValue::getBoolean(const String16& name, bool* output) const
 {
     protocol::Value* value = get(name);
     if (!value)
         return false;
     return value->asBoolean(output);
@@ skipping 54 matching lines @@
             break;
         }
     }
 }
 
 void DictionaryValue::writeJSON(String16Builder* output) const
 {
     output->append('{');
     for (size_t i = 0; i < m_order.size(); ++i) {
         Dictionary::const_iterator it = m_data.find(m_order[i]);
-        ASSERT_WITH_SECURITY_IMPLICATION(it != m_data.end());
+        CHECK(it != m_data.end());
         if (i)
             output->append(',');
         doubleQuoteStringForJSON(it->first, output);
         output->append(':');
         it->second->writeJSON(output);
     }
     output->append('}');
 }
 
 PassOwnPtr<Value> DictionaryValue::clone() const
 {
     OwnPtr<DictionaryValue> result = DictionaryValue::create();
     for (size_t i = 0; i < m_order.size(); ++i) {
         String16 key = m_order[i];
         Value* value = m_data.get(key);
-        ASSERT(value);
+        DCHECK(value);
         result->setValue(key, value->clone());
     }
     return std::move(result);
 }
 
 DictionaryValue::DictionaryValue()
     : Value(TypeObject)
 {
 }
 
@@ skipping 20 matching lines @@
     return std::move(result);
 }
 
 ListValue::ListValue()
     : Value(TypeArray)
 {
 }
 
 void ListValue::pushValue(PassOwnPtr<protocol::Value> value)
 {
-    ASSERT(value);
+    DCHECK(value);
     m_data.append(std::move(value));
 }
 
 protocol::Value* ListValue::at(size_t index)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(index < m_data.size());
-    return m_data[index].get();
+    return m_data[index];
 }
 
 } // namespace protocol
 } // namespace blink