tools/gn: Remove includes of basictypes.h.

tools/gn/value.h

 // Copyright (c) 2013 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.
 
 #ifndef TOOLS_GN_VALUE_H_
 #define TOOLS_GN_VALUE_H_
 
+#include <stdint.h>
 #include <map>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/strings/string_piece.h"
 #include "tools/gn/err.h"
 
 class ParseNode;
 class Scope;
 
 // Represents a variable value in the interpreter.
 class Value {
  public:
   enum Type {
     NONE = 0,
     BOOLEAN,
     INTEGER,
     STRING,
     LIST,
     SCOPE,
   };
 
   Value();
   Value(const ParseNode* origin, Type t);
   Value(const ParseNode* origin, bool bool_val);
-  Value(const ParseNode* origin, int64 int_val);
+  Value(const ParseNode* origin, int64_t int_val);
   Value(const ParseNode* origin, std::string str_val);
   Value(const ParseNode* origin, const char* str_val);
   // Values "shouldn't" have null scopes when type == Scope, so be sure to
   // always set one. However, this is not asserted since there are some
   // use-cases for creating values and immediately setting the scope on it. So
   // you can pass a null scope here if you promise to set it before any other
   // code gets it (code will generally assume the scope is not null).
   Value(const ParseNode* origin, scoped_ptr<Scope> scope);
 
   Value(const Value& other);
@@ skipping 12 matching lines @@
 
   bool& boolean_value() {
     DCHECK(type_ == BOOLEAN);
     return boolean_value_;
   }
   const bool& boolean_value() const {
     DCHECK(type_ == BOOLEAN);
     return boolean_value_;
   }
 
-  int64& int_value() {
+  int64_t& int_value() {
     DCHECK(type_ == INTEGER);
     return int_value_;
   }
-  const int64& int_value() const {
+  const int64_t& int_value() const {
     DCHECK(type_ == INTEGER);
     return int_value_;
   }
 
   std::string& string_value() {
     DCHECK(type_ == STRING);
     return string_value_;
   }
   const std::string& string_value() const {
     DCHECK(type_ == STRING);
@@ skipping 33 matching lines @@
   bool operator!=(const Value& other) const;
 
  private:
   // This are a lot of objects associated with every Value that need
   // initialization and tear down every time. It might be more efficient to
   // create a union of ManualConstructor objects (see SmallMap) and only
   // use the one we care about.
   Type type_;
   std::string string_value_;
   bool boolean_value_;
-  int64 int_value_;
+  int64_t int_value_;
   std::vector<Value> list_value_;
   scoped_ptr<Scope> scope_value_;
 
   const ParseNode* origin_;
 };
 
 #endif  // TOOLS_GN_VALUE_H_