Enable concurrent optimization test after migrating scopes to Thread*

runtime/vm/flow_graph_inliner.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_inliner.h"
 
 #include "vm/block_scheduler.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
@@ skipping 669 matching lines @@
     // Save and clear deopt id.
     const intptr_t prev_deopt_id = isolate()->deopt_id();
     isolate()->set_deopt_id(0);
     // Install bailout jump.
     LongJumpScope jump;
     if (setjmp(*jump.Set()) == 0) {
       // Parse the callee function.
       bool in_cache;
       ParsedFunction* parsed_function;
       {
-        CSTAT_TIMER_SCOPE(isolate(), graphinliner_parse_timer);
+        CSTAT_TIMER_SCOPE(thread(), graphinliner_parse_timer);
         if (!Compiler::always_optimize()) {
           const Error& error = Error::Handle(Z,
               Compiler::EnsureUnoptimizedCode(Thread::Current(), function));
           if (!error.IsNull()) {
             Exceptions::PropagateError(error);
           }
         }
         parsed_function = GetParsedFunction(function, &in_cache);
       }
 
       // Load IC data for the callee.
       ZoneGrowableArray<const ICData*>* ic_data_array =
             new(Z) ZoneGrowableArray<const ICData*>();
       function.RestoreICDataMap(ic_data_array);
 
       // Build the callee graph.
       InlineExitCollector* exit_collector =
           new(Z) InlineExitCollector(caller_graph_, call);
       FlowGraphBuilder builder(*parsed_function,
                                *ic_data_array,
                                exit_collector,
                                Isolate::kNoDeoptId);
       builder.SetInitialBlockId(caller_graph_->max_block_id());
       FlowGraph* callee_graph;
       {
-        CSTAT_TIMER_SCOPE(isolate(), graphinliner_build_timer);
+        CSTAT_TIMER_SCOPE(thread(), graphinliner_build_timer);
         callee_graph = builder.BuildGraph();
       }
 
       // The parameter stubs are a copy of the actual arguments providing
       // concrete information about the values, for example constant values,
       // without linking between the caller and callee graphs.
       // TODO(zerny): Put more information in the stubs, eg, type information.
       ZoneGrowableArray<Definition*>* param_stubs =
           new(Z) ZoneGrowableArray<Definition*>(
               function.NumParameters());
@@ skipping 33 matching lines @@
              !it.Done(); it.Advance()) {
           BlockEntryInstr* block = it.Current();
           block->set_try_index(try_index);
         }
       }
 
       BlockScheduler block_scheduler(callee_graph);
       block_scheduler.AssignEdgeWeights();
 
       {
-        CSTAT_TIMER_SCOPE(isolate(), graphinliner_ssa_timer);
+        CSTAT_TIMER_SCOPE(thread(), graphinliner_ssa_timer);
         // Compute SSA on the callee graph, catching bailouts.
         callee_graph->ComputeSSA(caller_graph_->max_virtual_register_number(),
                                  param_stubs);
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
       }
 
       {
-        CSTAT_TIMER_SCOPE(isolate(), graphinliner_opt_timer);
+        CSTAT_TIMER_SCOPE(thread(), graphinliner_opt_timer);
         // TODO(zerny): Do more optimization passes on the callee graph.
         FlowGraphOptimizer optimizer(callee_graph);
         if (Compiler::always_optimize()) {
           optimizer.PopulateWithICData();
         }
         optimizer.ApplyICData();
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
 
         // Optimize (a << b) & c patterns, merge instructions. Must occur before
         // 'SelectRepresentations' which inserts conversion nodes.
@@ skipping 160 matching lines @@
         ISL_Print("NO %" Pd " %s - %s\n",
             info.call_instr->GetDeoptId(),
             info.inlined->ToQualifiedCString(),
             info.bailout_reason);
         call_instructions_printed.Add(info.call_instr->GetDeoptId());
       }
     }
   }
 
   void InlineCall(InlinedCallData* call_data) {
-    CSTAT_TIMER_SCOPE(Isolate::Current(), graphinliner_subst_timer);
+    CSTAT_TIMER_SCOPE(Thread::Current(), graphinliner_subst_timer);
     FlowGraph* callee_graph = call_data->callee_graph;
     TargetEntryInstr* callee_entry =
         callee_graph->graph_entry()->normal_entry();
     // Plug result in the caller graph.
     InlineExitCollector* exit_collector = call_data->exit_collector;
     exit_collector->PrepareGraphs(callee_graph);
     exit_collector->ReplaceCall(callee_entry);
 
     // Replace each stub with the actual argument or the caller's constant.
     // Nulls denote optional parameters for which no actual was given.
@@ skipping 924 matching lines @@
 intptr_t FlowGraphInliner::NextInlineId(const Function& function,
                                         intptr_t parent_id) {
   const intptr_t id = inline_id_to_function_->length();
   inline_id_to_function_->Add(&function);
   caller_inline_id_->Add(parent_id);
   return id;
 }
 
 
 }  // namespace dart