Getting rid of Isolate::current_zone() usage. Pass thread instead of isolate where it makes sense.

runtime/vm/profiler_service.cc

 // Copyright (c) 2015, 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/profiler_service.h"
 
 #include "vm/growable_array.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
 #include "vm/os.h"
@@ skipping 966 matching lines @@
   enum ProfileInfoKind {
     kNone,
     kOptimized,
     kUnoptimized,
     kNative,
     kInlineStart,
     kInlineFinish,
     kNumProfileInfoKind,
   };
 
-  ProfileBuilder(Isolate* isolate,
+  ProfileBuilder(Thread* thread,
                  SampleFilter* filter,
                  Profile::TagOrder tag_order,
                  intptr_t extra_tags,
                  Profile* profile)
-      : isolate_(isolate),
+      : thread_(thread),
         vm_isolate_(Dart::vm_isolate()),
         filter_(filter),
         tag_order_(tag_order),
         extra_tags_(extra_tags),
         profile_(profile),
-        deoptimized_code_(new DeoptimizedCodeSet(isolate)),
+        deoptimized_code_(new DeoptimizedCodeSet(thread->isolate())),
         null_code_(Code::ZoneHandle()),
         null_function_(Function::ZoneHandle()),
         tick_functions_(false),
         inclusive_tree_(false),
         samples_(NULL),
         info_kind_(kNone) {
     ASSERT(profile_ != NULL);
   }
 
   void Build() {
@@ skipping 35 matching lines @@
     RegisterProfileCodeTag(VMTag::kNoneCodeTagId);
     RegisterProfileCodeTag(VMTag::kOptimizedCodeTagId);
     RegisterProfileCodeTag(VMTag::kUnoptimizedCodeTagId);
     RegisterProfileCodeTag(VMTag::kNativeCodeTagId);
     RegisterProfileCodeTag(VMTag::kInlineStartCodeTagId);
     RegisterProfileCodeTag(VMTag::kInlineEndCodeTagId);
   }
 
   void FilterSamples() {
     ScopeTimer sw("ProfileBuilder::FilterSamples", FLAG_trace_profiler);
-    MutexLocker profiler_data_lock(isolate_->profiler_data_mutex());
-    IsolateProfilerData* profiler_data = isolate_->profiler_data();
+    Isolate* isolate = thread_->isolate();
+    MutexLocker profiler_data_lock(isolate->profiler_data_mutex());
+    IsolateProfilerData* profiler_data = isolate->profiler_data();
     if (profiler_data == NULL) {
       return;
     }
     SampleBuffer* sample_buffer = profiler_data->sample_buffer();
     if (sample_buffer == NULL) {
       return;
     }
     samples_ = sample_buffer->BuildProcessedSampleBuffer(filter_);
     profile_->sample_count_ = samples_->length();
   }
@@ skipping 772 matching lines @@
                                         pc,
                                         pc + 1,
                                         0,
                                         null_code_);
     return code;
   }
 
   ProfileCode* CreateProfileCode(uword pc) {
     const intptr_t kDartCodeAlignment = OS::PreferredCodeAlignment();
     const intptr_t kDartCodeAlignmentMask = ~(kDartCodeAlignment - 1);
-    Code& code = Code::Handle(isolate_->current_zone());
+    Code& code = Code::Handle(thread_->zone());
 
     // Check current isolate for pc.
-    if (isolate_->heap()->CodeContains(pc)) {
+    if (thread_->isolate()->heap()->CodeContains(pc)) {
       code ^= Code::LookupCode(pc);
       if (!code.IsNull()) {
         deoptimized_code_->Add(code);
         return new ProfileCode(ProfileCode::kDartCode,
                               code.EntryPoint(),
                               code.EntryPoint() + code.Size(),
                               code.compile_timestamp(),
                               code);
       }
       return new ProfileCode(ProfileCode::kCollectedCode,
@@ skipping 88 matching lines @@
   bool vm_tags_emitted() const {
     return (tag_order_ == Profile::kUserVM) ||
            (tag_order_ == Profile::kVMUser) ||
            (tag_order_ == Profile::kVM);
   }
 
   bool TagsEnabled(intptr_t extra_tags_bits) const {
     return (extra_tags_ & extra_tags_bits) != 0;
   }
 
-  Isolate* isolate_;
+  Thread* thread_;
   Isolate* vm_isolate_;
   SampleFilter* filter_;
   Profile::TagOrder tag_order_;
   intptr_t extra_tags_;
   Profile* profile_;
   DeoptimizedCodeSet* deoptimized_code_;
   const Code& null_code_;
   const Function& null_function_;
   bool tick_functions_;
   bool inclusive_tree_;
 
   ProcessedSampleBuffer* samples_;
   ProfileInfoKind info_kind_;
-};
+};  // ProfileBuilder.
 
 
 Profile::Profile(Isolate* isolate)
     : isolate_(isolate),
       live_code_(NULL),
       dead_code_(NULL),
       tag_code_(NULL),
       functions_(NULL),
       dead_code_index_offset_(-1),
       tag_code_index_offset_(-1),
       min_time_(kMaxInt64),
       max_time_(0) {
   ASSERT(isolate_ != NULL);
   for (intptr_t i = 0; i < kNumTrieKinds; i++) {
     roots_[i] = NULL;
   }
 }
 
 
-void Profile::Build(SampleFilter* filter,
+void Profile::Build(Thread* thread,
+                    SampleFilter* filter,
                     TagOrder tag_order,
                     intptr_t extra_tags) {
-  ProfileBuilder builder(isolate_, filter, tag_order, extra_tags, this);
+  ProfileBuilder builder(thread, filter, tag_order, extra_tags, this);
   builder.Build();
 }
 
 
 ProfileFunction* Profile::GetFunction(intptr_t index) {
   ASSERT(functions_ != NULL);
   return functions_->At(index);
 }
 
 
@@ skipping 201 matching lines @@
     if (profiler_data == NULL) {
       stream->PrintError(kFeatureDisabled, NULL);
       return;
     }
   }
 
   {
     StackZone zone(thread);
     HANDLESCOPE(thread);
     Profile profile(isolate);
-    profile.Build(filter, tag_order, extra_tags);
+    profile.Build(thread, filter, tag_order, extra_tags);
     profile.PrintJSON(stream);
   }
 
   // Enable profile interrupts.
   Profiler::BeginExecution(isolate);
 }
 
 
 class NoAllocationSampleFilter : public SampleFilter {
  public:
@@ skipping 60 matching lines @@
   ASSERT(sample_buffer != NULL);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 
   // Enable profile interrupts.
   Profiler::BeginExecution(isolate);
 }
 
 }  // namespace dart