Replace OStream with std::ostream.

src/compiler/operator.h

 // Copyright 2013 the V8 project 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 V8_COMPILER_OPERATOR_H_
 #define V8_COMPILER_OPERATOR_H_
 
 #include "src/base/flags.h"
 #include "src/ostreams.h"
 #include "src/unique.h"
@@ skipping 69 matching lines @@
 
   // Number of data outputs from the operator, for verifying graph structure.
   virtual int OutputCount() const = 0;
 
   Properties properties() const { return properties_; }
 
   // TODO(titzer): API for input and output types, for typechecking graph.
  protected:
   // Print the full operator into the given stream, including any
   // static parameters. Useful for debugging and visualizing the IR.
-  virtual OStream& PrintTo(OStream& os) const = 0;  // NOLINT
-  friend OStream& operator<<(OStream& os, const Operator& op);
+  virtual std::ostream& PrintTo(std::ostream& os) const = 0;  // NOLINT
+  friend std::ostream& operator<<(std::ostream& os, const Operator& op);
 
  private:
   Opcode opcode_;
   Properties properties_;
   const char* mnemonic_;
 
   DISALLOW_COPY_AND_ASSIGN(Operator);
 };
 
 DEFINE_OPERATORS_FOR_FLAGS(Operator::Properties)
 
-OStream& operator<<(OStream& os, const Operator& op);
+std::ostream& operator<<(std::ostream& os, const Operator& op);
 
 // An implementation of Operator that has no static parameters. Such operators
 // have just a name, an opcode, and a fixed number of inputs and outputs.
 // They can represented by singletons and shared globally.
 class SimpleOperator : public Operator {
  public:
   SimpleOperator(Opcode opcode, Properties properties, int input_count,
                  int output_count, const char* mnemonic);
   ~SimpleOperator();
 
   virtual bool Equals(const Operator* that) const FINAL {
     return opcode() == that->opcode();
   }
   virtual int HashCode() const FINAL { return opcode(); }
   virtual int InputCount() const FINAL { return input_count_; }
   virtual int OutputCount() const FINAL { return output_count_; }
 
  private:
-  virtual OStream& PrintTo(OStream& os) const FINAL {  // NOLINT
+  virtual std::ostream& PrintTo(std::ostream& os) const FINAL {  // NOLINT
     return os << mnemonic();
   }
 
   int input_count_;
   int output_count_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleOperator);
 };
 
 // Template specialization implements a kind of type class for dealing with the
 // static parameters of Operator1 automatically.
 template <typename T>
 struct StaticParameterTraits {
-  static OStream& PrintTo(OStream& os, T val) {  // NOLINT
+  static std::ostream& PrintTo(std::ostream& os, T val) {  // NOLINT
     return os << "??";
   }
   static int HashCode(T a) { return 0; }
   static bool Equals(T a, T b) {
     return false;  // Not every T has a ==. By default, be conservative.
   }
 };
 
 // Specialization for static parameters of type {int}.
 template <>
 struct StaticParameterTraits<int> {
-  static OStream& PrintTo(OStream& os, int val) {  // NOLINT
+  static std::ostream& PrintTo(std::ostream& os, int val) {  // NOLINT
     return os << val;
   }
   static int HashCode(int a) { return a; }
   static bool Equals(int a, int b) { return a == b; }
 };
 
 // Specialization for static parameters of type {double}.
 template <>
 struct StaticParameterTraits<double> {
-  static OStream& PrintTo(OStream& os, double val) {  // NOLINT
+  static std::ostream& PrintTo(std::ostream& os, double val) {  // NOLINT
     return os << val;
   }
   static int HashCode(double a) {
     return static_cast<int>(bit_cast<int64_t>(a));
   }
   static bool Equals(double a, double b) {
     return bit_cast<int64_t>(a) == bit_cast<int64_t>(b);
   }
 };
 
 // Specialization for static parameters of type {Unique<Object>}.
 template <>
 struct StaticParameterTraits<Unique<Object> > {
-  static OStream& PrintTo(OStream& os, Unique<Object> val) {  // NOLINT
+  static std::ostream& PrintTo(std::ostream& os,
+                               Unique<Object> val) {  // NOLINT
     return os << Brief(*val.handle());
   }
   static int HashCode(Unique<Object> a) {
     return static_cast<int>(a.Hashcode());
   }
   static bool Equals(Unique<Object> a, Unique<Object> b) { return a == b; }
 };
 
 // Specialization for static parameters of type {Unique<Name>}.
 template <>
 struct StaticParameterTraits<Unique<Name> > {
-  static OStream& PrintTo(OStream& os, Unique<Name> val) {  // NOLINT
+  static std::ostream& PrintTo(std::ostream& os, Unique<Name> val) {  // NOLINT
     return os << Brief(*val.handle());
   }
   static int HashCode(Unique<Name> a) { return static_cast<int>(a.Hashcode()); }
   static bool Equals(Unique<Name> a, Unique<Name> b) { return a == b; }
 };
 
 #if DEBUG
 // Specialization for static parameters of type {Handle<Object>} to prevent any
 // direct usage of Handles in constants.
 template <>
 struct StaticParameterTraits<Handle<Object> > {
-  static OStream& PrintTo(OStream& os, Handle<Object> val) {  // NOLINT
+  static std::ostream& PrintTo(std::ostream& os,
+                               Handle<Object> val) {  // NOLINT
     UNREACHABLE();  // Should use Unique<Object> instead
     return os;
   }
   static int HashCode(Handle<Object> a) {
     UNREACHABLE();  // Should use Unique<Object> instead
     return 0;
   }
   static bool Equals(Handle<Object> a, Handle<Object> b) {
     UNREACHABLE();  // Should use Unique<Object> instead
     return false;
@@ skipping 19 matching lines @@
   virtual bool Equals(const Operator* other) const OVERRIDE {
     if (opcode() != other->opcode()) return false;
     const Operator1<T>* that = static_cast<const Operator1<T>*>(other);
     return StaticParameterTraits<T>::Equals(this->parameter_, that->parameter_);
   }
   virtual int HashCode() const OVERRIDE {
     return opcode() + 33 * StaticParameterTraits<T>::HashCode(this->parameter_);
   }
   virtual int InputCount() const OVERRIDE { return input_count_; }
   virtual int OutputCount() const OVERRIDE { return output_count_; }
-  virtual OStream& PrintParameter(OStream& os) const {  // NOLINT
+  virtual std::ostream& PrintParameter(std::ostream& os) const {  // NOLINT
     return StaticParameterTraits<T>::PrintTo(os << "[", parameter_) << "]";
   }
 
  protected:
-  virtual OStream& PrintTo(OStream& os) const FINAL {  // NOLINT
+  virtual std::ostream& PrintTo(std::ostream& os) const FINAL {  // NOLINT
     return PrintParameter(os << mnemonic());
   }
 
  private:
   int input_count_;
   int output_count_;
   T parameter_;
 };
 
 
 // Helper to extract parameters from Operator1<*> operator.
 template <typename T>
 static inline const T& OpParameter(const Operator* op) {
   return reinterpret_cast<const Operator1<T>*>(op)->parameter();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_OPERATOR_H_