Use Chrome compatible naming for compiler specifics.

src/ic/ic.h

 // Copyright 2012 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_IC_H_
 #define V8_IC_H_
 
 #include "src/macro-assembler.h"
 
 namespace v8 {
@@ skipping 279 matching lines @@
  private:
   Address address_;
   IC::UtilityId id_;
 };
 
 
 class CallIC : public IC {
  public:
   enum CallType { METHOD, FUNCTION };
 
-  class State V8_FINAL BASE_EMBEDDED {
+  class State FINAL BASE_EMBEDDED {
    public:
     explicit State(ExtraICState extra_ic_state);
 
     State(int argc, CallType call_type) : argc_(argc), call_type_(call_type) {}
 
     ExtraICState GetExtraICState() const;
 
     static void GenerateAheadOfTime(Isolate*,
                                     void (*Generate)(Isolate*, const State&));
 
@@ skipping 34 matching lines @@
   inline IC::State FeedbackToState(Handle<FixedArray> vector,
                                    Handle<Smi> slot) const;
 };
 
 
 OStream& operator<<(OStream& os, const CallIC::State& s);
 
 
 class LoadIC : public IC {
  public:
-  class State V8_FINAL BASE_EMBEDDED {
+  class State FINAL BASE_EMBEDDED {
    public:
     explicit State(ExtraICState extra_ic_state) : state_(extra_ic_state) {}
 
     explicit State(ContextualMode mode)
         : state_(ContextualModeBits::encode(mode)) {}
 
     ExtraICState GetExtraICState() const { return state_; }
 
     ContextualMode contextual_mode() const {
       return ContextualModeBits::decode(state_);
@@ skipping 317 matching lines @@
   friend class IC;
 };
 
 
 // Mode to overwrite BinaryExpression values.
 enum OverwriteMode { NO_OVERWRITE, OVERWRITE_LEFT, OVERWRITE_RIGHT };
 
 // Type Recording BinaryOpIC, that records the types of the inputs and outputs.
 class BinaryOpIC : public IC {
  public:
-  class State V8_FINAL BASE_EMBEDDED {
+  class State FINAL BASE_EMBEDDED {
    public:
     State(Isolate* isolate, ExtraICState extra_ic_state);
 
     State(Isolate* isolate, Token::Value op, OverwriteMode mode)
         : op_(op),
           mode_(mode),
           left_kind_(NONE),
           right_kind_(NONE),
           result_kind_(NONE),
           isolate_(isolate) {
@@ skipping 103 matching lines @@
     Maybe<int> fixed_right_arg_;
     Isolate* isolate_;
   };
 
   explicit BinaryOpIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) {}
 
   static Builtins::JavaScript TokenToJSBuiltin(Token::Value op);
 
   MaybeHandle<Object> Transition(Handle<AllocationSite> allocation_site,
                                  Handle<Object> left,
-                                 Handle<Object> right) V8_WARN_UNUSED_RESULT;
+                                 Handle<Object> right) WARN_UNUSED_RESULT;
 };
 
 
 OStream& operator<<(OStream& os, const BinaryOpIC::State& s);
 
 
 class CompareIC : public IC {
  public:
   // The type/state lattice is defined by the following inequations:
   //   UNINITIALIZED < ...
@@ skipping 103 matching lines @@
 
 // Support functions for interceptor handlers.
 DECLARE_RUNTIME_FUNCTION(LoadPropertyWithInterceptorOnly);
 DECLARE_RUNTIME_FUNCTION(LoadPropertyWithInterceptor);
 DECLARE_RUNTIME_FUNCTION(LoadElementWithInterceptor);
 DECLARE_RUNTIME_FUNCTION(StorePropertyWithInterceptor);
 }
 }  // namespace v8::internal
 
 #endif  // V8_IC_H_