Move platform abstraction to base library

tools/lexer-shell.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 16 matching lines @@
 
 #include <assert.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 #include <vector>
 #include "src/v8.h"
 
 #include "src/api.h"
+#include "src/base/platform/platform.h"
 #include "src/messages.h"
-#include "src/platform.h"
 #include "src/runtime.h"
 #include "src/scanner-character-streams.h"
 #include "src/scopeinfo.h"
 #include "tools/shell-utils.h"
 #include "src/string-stream.h"
 #include "src/scanner.h"
 
 
 using namespace v8::internal;
 
 
 class BaselineScanner {
  public:
   BaselineScanner(const char* fname,
                   Isolate* isolate,
                   Encoding encoding,
-                  ElapsedTimer* timer,
+                  v8::base::ElapsedTimer* timer,
                   int repeat)
       : stream_(NULL) {
     int length = 0;
     source_ = ReadFileAndRepeat(fname, &length, repeat);
     unicode_cache_ = new UnicodeCache();
     scanner_ = new Scanner(unicode_cache_);
     switch (encoding) {
       case UTF8:
         stream_ = new Utf8ToUtf16CharacterStream(source_, length);
         break;
@@ skipping 54 matching lines @@
     return !(*this == other);
   }
   void Print(const char* prefix) const {
     printf("%s %11s at (%d, %d)\n",
            prefix, Token::Name(value),
            static_cast<int>(beg), static_cast<int>(end));
   }
 };
 
 
-TimeDelta RunBaselineScanner(const char* fname,
-                             Isolate* isolate,
-                             Encoding encoding,
-                             bool dump_tokens,
-                             std::vector<TokenWithLocation>* tokens,
-                             int repeat) {
-  ElapsedTimer timer;
+v8::base::TimeDelta RunBaselineScanner(const char* fname, Isolate* isolate,
+                                       Encoding encoding, bool dump_tokens,
+                                       std::vector<TokenWithLocation>* tokens,
+                                       int repeat) {
+  v8::base::ElapsedTimer timer;
   BaselineScanner scanner(fname, isolate, encoding, &timer, repeat);
   Token::Value token;
   int beg, end;
   do {
     token = scanner.Next(&beg, &end);
     if (dump_tokens) {
       tokens->push_back(TokenWithLocation(token, beg, end));
     }
   } while (token != Token::EOS);
   return timer.Elapsed();
 }
 
 
 void PrintTokens(const char* name,
                  const std::vector<TokenWithLocation>& tokens) {
   printf("No of tokens: %d\n",
          static_cast<int>(tokens.size()));
   printf("%s:\n", name);
   for (size_t i = 0; i < tokens.size(); ++i) {
     tokens[i].Print("=>");
   }
 }
 
 
-TimeDelta ProcessFile(
+v8::base::TimeDelta ProcessFile(
     const char* fname,
     Encoding encoding,
     Isolate* isolate,
     bool print_tokens,
     int repeat) {
   if (print_tokens) {
     printf("Processing file %s\n", fname);
   }
   HandleScope handle_scope(isolate);
   std::vector<TokenWithLocation> baseline_tokens;
-  TimeDelta baseline_time;
+  v8::base::TimeDelta baseline_time;
   baseline_time = RunBaselineScanner(
       fname, isolate, encoding, print_tokens,
       &baseline_tokens, repeat);
   if (print_tokens) {
     PrintTokens("Baseline", baseline_tokens);
   }
   return baseline_time;
 }
 
 
@@ skipping 27 matching lines @@
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
     v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
     ASSERT(!context.IsEmpty());
     {
       v8::Context::Scope scope(context);
       double baseline_total = 0;
       for (size_t i = 0; i < fnames.size(); i++) {
-        TimeDelta time;
+        v8::base::TimeDelta time;
         time = ProcessFile(fnames[i].c_str(), encoding,
                            reinterpret_cast<Isolate*>(isolate), print_tokens,
                            repeat);
         baseline_total += time.InMillisecondsF();
       }
       if (benchmark.empty()) benchmark = "Baseline";
       printf("%s(RunTime): %.f ms\n", benchmark.c_str(), baseline_total);
     }
   }
   v8::V8::Dispose();
   return 0;
 }