Replace OStream with std::ostream.

src/compiler/common-operator.cc

 // Copyright 2014 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.
 
 #include "src/compiler/common-operator.h"
 
 #include "src/assembler.h"
 #include "src/base/lazy-instance.h"
 #include "src/compiler/linkage.h"
 #include "src/unique.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
 
 // TODO(turbofan): Use size_t instead of int here.
 class ControlOperator : public Operator1<int> {
  public:
   ControlOperator(IrOpcode::Value opcode, Properties properties, int inputs,
                   int outputs, int controls, const char* mnemonic)
       : Operator1<int>(opcode, properties, inputs, outputs, mnemonic,
                        controls) {}
 
-  virtual OStream& PrintParameter(OStream& os) const FINAL { return os; }
+  virtual std::ostream& PrintParameter(std::ostream& os) const FINAL {
+    return os;
+  }
 };
 
 }  // namespace
 
 
 // Specialization for static parameters of type {ExternalReference}.
 template <>
 struct StaticParameterTraits<ExternalReference> {
-  static OStream& PrintTo(OStream& os, ExternalReference reference) {
+  static std::ostream& PrintTo(std::ostream& os, ExternalReference reference) {
     os << reference.address();
     // TODO(bmeurer): Move to operator<<(os, ExternalReference)
     const Runtime::Function* function =
         Runtime::FunctionForEntry(reference.address());
     if (function) {
       os << " <" << function->name << ".entry>";
     }
     return os;
   }
   static int HashCode(ExternalReference reference) {
@@ skipping 180 matching lines @@
     // TODO(titzer): Operator still uses int, whereas CallDescriptor uses
     // size_t.
     CallOperator(const CallDescriptor* descriptor, const char* mnemonic)
         : Operator1<const CallDescriptor*>(
               IrOpcode::kCall, descriptor->properties(),
               static_cast<int>(descriptor->InputCount() +
                                descriptor->FrameStateCount()),
               static_cast<int>(descriptor->ReturnCount()), mnemonic,
               descriptor) {}
 
-    virtual OStream& PrintParameter(OStream& os) const OVERRIDE {
+    virtual std::ostream& PrintParameter(std::ostream& os) const OVERRIDE {
       return os << "[" << *parameter() << "]";
     }
   };
   return new (zone()) CallOperator(descriptor, "Call");
 }
 
 
 const Operator* CommonOperatorBuilder::Projection(size_t index) {
   return new (zone()) Operator1<size_t>(IrOpcode::kProjection, Operator::kPure,
                                         1, 1, "Projection", index);
@@ skipping 39 matching lines @@
 }
 
 
 bool OutputFrameStateCombine::IsOutputIgnored() {
   return kind() == kPushOutput && GetPushCount() == 0;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8