[DevTools] Generate all files in inspector_protocol.

third_party/WebKit/Source/platform/inspector_protocol/Values_cpp.template

 // 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 <algorithm>
 #include <cmath>
 
 namespace blink {
 namespace protocol {
 
 namespace {
 
-const char* const nullString = "null";
-const char* const trueString = "true";
-const char* const falseString = "false";
+const char* const nullValueString = "null";
+const char* const trueValueString = "true";
+const char* const falseValueString = "false";
 
 inline bool escapeChar(UChar c, String16Builder* dst)
 {
     switch (c) {
     case '\b': dst->append("\\b"); break;
     case '\f': dst->append("\\f"); break;
     case '\n': dst->append("\\n"); break;
     case '\r': dst->append("\\r"); break;
     case '\t': dst->append("\\t"); break;
     case '\\': dst->append("\\\\"); break;
@@ skipping 71 matching lines @@
 {
     String16Builder result;
     result.reserveCapacity(512);
     writeJSON(&result);
     return result.toString();
 }
 
 void Value::writeJSON(String16Builder* output) const
 {
     DCHECK(m_type == TypeNull);
-    output->append(nullString, 4);
+    output->append(nullValueString, 4);
 }
 
 std::unique_ptr<Value> Value::clone() const
 {
     return Value::null();
 }
 
 bool FundamentalValue::asBoolean(bool* output) const
 {
     if (type() != TypeBoolean)
@@ skipping 21 matching lines @@
         return false;
     *output = m_integerValue;
     return true;
 }
 
 void FundamentalValue::writeJSON(String16Builder* output) const
 {
     DCHECK(type() == TypeBoolean || type() == TypeInteger || type() == TypeDouble);
     if (type() == TypeBoolean) {
         if (m_boolValue)
-            output->append(trueString, 4);
+            output->append(trueValueString, 4);
         else
-            output->append(falseString, 5);
+            output->append(falseValueString, 5);
     } else if (type() == TypeDouble) {
         if (!std::isfinite(m_doubleValue)) {
-            output->append(nullString, 4);
+            output->append(nullValueString, 4);
             return;
         }
         output->append(String16::fromDouble(m_doubleValue));
     } else if (type() == TypeInteger) {
         output->append(String16::fromInteger(m_integerValue));
     }
 }
 
 std::unique_ptr<Value> FundamentalValue::clone() const
 {
@@ skipping 232 matching lines @@
 }
 
 protocol::Value* ListValue::at(size_t index)
 {
     DCHECK_LT(index, m_data.size());
     return m_data[index].get();
 }
 
 } // namespace protocol
 } // namespace blink