Fix use of history timers in background threads.

src/wasm/module-compiler.h

 // Copyright 2017 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_WASM_MODULE_COMPILER_H_
 #define V8_WASM_MODULE_COMPILER_H_
 
 #include <functional>
 
 #include "src/base/atomic-utils.h"
@@ skipping 41 matching lines @@
 
    private:
     size_t GetRandomIndexInSchedule();
 
     base::RandomNumberGenerator* random_number_generator_ = nullptr;
     std::vector<std::unique_ptr<compiler::WasmCompilationUnit>> schedule_;
   };
 
   Isolate* isolate_;
   std::unique_ptr<WasmModule> module_;
-  std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
+  const std::shared_ptr<Counters> counters_shared_;
   bool is_sync_;
   std::vector<std::unique_ptr<compiler::WasmCompilationUnit>>
       compilation_units_;
   CodeGenerationSchedule executed_units_;
   base::Mutex result_mutex_;
   base::AtomicNumber<size_t> next_unit_;
   size_t num_background_tasks_ = 0;
   // This flag should only be set while holding result_mutex_.
   bool finisher_is_running_ = false;
 
+  Counters* counters() const { return counters_shared_.get(); }
+
   // Run by each compilation task and by the main thread. The
   // no_finisher_callback is called within the result_mutex_ lock when no
   // finishing task is running, i.e. when the finisher_is_running_ flag is not
   // set.
   bool FetchAndExecuteCompilationUnit(
       std::function<void()> no_finisher_callback = [] {});
 
   size_t InitializeParallelCompilation(
       const std::vector<WasmFunction>& functions, ModuleBytesEnv& module_env);
 
@@ skipping 65 matching lines @@
   // Represents the initialized state of a table.
   struct TableInstance {
     Handle<WasmTableObject> table_object;  // WebAssembly.Table instance
     Handle<FixedArray> js_wrappers;        // JSFunctions exported
     Handle<FixedArray> function_table;     // internal code array
     Handle<FixedArray> signature_table;    // internal sig array
   };
 
   Isolate* isolate_;
   WasmModule* const module_;
-  std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
+  const std::shared_ptr<Counters> counters_shared_;
   ErrorThrower* thrower_;
   Handle<WasmModuleObject> module_object_;
   Handle<JSReceiver> ffi_;        // TODO(titzer): Use MaybeHandle
   Handle<JSArrayBuffer> memory_;  // TODO(titzer): Use MaybeHandle
   Handle<JSArrayBuffer> globals_;
   Handle<WasmCompiledModule> compiled_module_;
   std::vector<TableInstance> table_instances_;
   std::vector<Handle<JSFunction>> js_wrappers_;
   JSToWasmWrapperCache js_to_wasm_cache_;
   WeakCallbackInfo<void>::Callback instance_finalizer_callback_;
 
+  Counters* counters() const { return counters_shared_.get(); }
+
 // Helper routines to print out errors with imports.
 #define ERROR_THROWER_WITH_MESSAGE(TYPE)                                      \
   void Report##TYPE(const char* error, uint32_t index,                        \
                     Handle<String> module_name, Handle<String> import_name) { \
     thrower_->TYPE("Import #%d module=\"%.*s\" function=\"%.*s\" error: %s",  \
                    index, module_name->length(),                              \
                    module_name->ToCString().get(), import_name->length(),     \
                    import_name->ToCString().get(), error);                    \
   }                                                                           \
                                                                               \
@@ skipping 71 matching lines @@
   explicit AsyncCompileJob(Isolate* isolate, std::unique_ptr<byte[]> bytes_copy,
                            size_t length, Handle<Context> context,
                            Handle<JSPromise> promise);
 
   void Start();
 
   ~AsyncCompileJob();
 
  private:
   Isolate* isolate_;
-  std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
+  const std::shared_ptr<Counters> counters_shared_;
   std::unique_ptr<byte[]> bytes_copy_;
   ModuleWireBytes wire_bytes_;
   Handle<Context> context_;
   Handle<JSPromise> module_promise_;
   std::unique_ptr<ModuleCompiler> compiler_;
   std::unique_ptr<ModuleBytesEnv> module_bytes_env_;
 
   bool failed_ = false;
   std::vector<DeferredHandles*> deferred_handles_;
   Handle<WasmModuleObject> module_object_;
   Handle<FixedArray> function_tables_;
   Handle<FixedArray> signature_tables_;
   Handle<WasmCompiledModule> compiled_module_;
   Handle<FixedArray> code_table_;
   std::unique_ptr<WasmInstance> temp_instance_ = nullptr;
   size_t outstanding_units_ = 0;
   size_t num_background_tasks_ = 0;
 
+  Counters* counters() const { return counters_shared_.get(); }
+
   void ReopenHandlesInDeferredScope();
 
   void AsyncCompileFailed(ErrorThrower& thrower);
 
   void AsyncCompileSucceeded(Handle<Object> result);
 
   template <typename Task, typename... Args>
   void DoSync(Args&&... args);
 
   template <typename Task, typename... Args>
@@ skipping 12 matching lines @@
   class FinishCompile;
   class CompileWrappers;
   class FinishModule;
 };
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_MODULE_COMPILER_H_