content/renderer/browser_exposed_renderer_interfaces.cc - chromium/src - Git at Google

 // Copyright 2019 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "content/renderer/browser_exposed_renderer_interfaces.h"

 #include <stdint.h>

 #include <memory>
 #include <utility>

 #include "base/feature_list.h"
 #include "base/functional/bind.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/task/task_runner.h"
 #include "base/task/thread_pool.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/common/features.h"
 #include "content/common/frame.mojom.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/resource_usage_reporter.mojom.h"
 #include "content/public/common/resource_usage_reporter_type_converters.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/service_worker/embedded_worker_instance_client_impl.h"
 #include "content/renderer/worker/shared_worker_factory_impl.h"
 #include "content/services/auction_worklet/auction_worklet_service_impl.h"
 #include "mojo/public/cpp/bindings/binder_map.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "v8/include/v8-isolate.h"
 #include "v8/include/v8-statistics.h"

 namespace content {

 namespace {

 constexpr int kWaitForWorkersStatsTimeoutMS = 20;

 class ResourceUsageReporterImpl : public content::mojom::ResourceUsageReporter {
  public:
   explicit ResourceUsageReporterImpl(base::WeakPtr<RenderThread> thread)
       : thread_(std::move(thread)) {}
   ResourceUsageReporterImpl(const ResourceUsageReporterImpl&) = delete;
   ~ResourceUsageReporterImpl() override = default;

   ResourceUsageReporterImpl& operator=(const ResourceUsageReporterImpl&) =
       delete;

  private:
   static void CollectOnWorkerThread(
       const scoped_refptr<base::TaskRunner>& master,
       base::WeakPtr<ResourceUsageReporterImpl> impl) {
     size_t total_bytes = 0;
     size_t used_bytes = 0;
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     if (isolate) {
       v8::HeapStatistics heap_stats;
       isolate->GetHeapStatistics(&heap_stats);
       total_bytes = heap_stats.total_heap_size();
       used_bytes = heap_stats.used_heap_size();
     }
     master->PostTask(FROM_HERE,
                      base::BindOnce(&ResourceUsageReporterImpl::ReceiveStats,
                                     impl, total_bytes, used_bytes));
   }

   void ReceiveStats(size_t total_bytes, size_t used_bytes) {
     usage_data_->v8_bytes_allocated += total_bytes;
     usage_data_->v8_bytes_used += used_bytes;
     workers_to_go_--;
     if (!workers_to_go_)
       SendResults();
   }

   void SendResults() {
     if (!callback_.is_null())
       std::move(callback_).Run(std::move(usage_data_));
     callback_.Reset();
     weak_factory_.InvalidateWeakPtrs();
     workers_to_go_ = 0;
   }

   void GetUsageData(GetUsageDataCallback callback) override {
     DCHECK(callback_.is_null());
     weak_factory_.InvalidateWeakPtrs();
     usage_data_ = mojom::ResourceUsageData::New();
     usage_data_->reports_v8_stats = true;
     callback_ = std::move(callback);

     // Since it is not safe to call any Blink or V8 functions until Blink has
     // been initialized (which also initializes V8), early out and send 0 back
     // for all resources.
     if (!thread_) {
       SendResults();
       return;
     }

     blink::WebCacheResourceTypeStats stats;
     blink::WebCache::GetResourceTypeStats(&stats);
     usage_data_->web_cache_stats = mojom::ResourceTypeStats::From(stats);

     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     if (isolate) {
       v8::HeapStatistics heap_stats;
       isolate->GetHeapStatistics(&heap_stats);
       usage_data_->v8_bytes_allocated = heap_stats.total_heap_size();
       usage_data_->v8_bytes_used = heap_stats.used_heap_size();
     }
     base::RepeatingClosure collect =
         base::BindRepeating(&ResourceUsageReporterImpl::CollectOnWorkerThread,
                             base::SingleThreadTaskRunner::GetCurrentDefault(),
                             weak_factory_.GetWeakPtr());
     workers_to_go_ =
         RenderThread::Get()->PostTaskToAllWebWorkers(std::move(collect));
     if (workers_to_go_) {
       // The guard task to send out partial stats
       // in case some workers are not responsive.
       base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
           FROM_HERE,
           base::BindOnce(&ResourceUsageReporterImpl::SendResults,
                          weak_factory_.GetWeakPtr()),
           base::Milliseconds(kWaitForWorkersStatsTimeoutMS));
     } else {
       // No worker threads so just send out the main thread data right away.
       SendResults();
     }
   }

   const base::WeakPtr<RenderThread> thread_;
   mojom::ResourceUsageDataPtr usage_data_;
   GetUsageDataCallback callback_;
   int workers_to_go_ = 0;

   base::WeakPtrFactory<ResourceUsageReporterImpl> weak_factory_{this};
 };

 void CreateResourceUsageReporter(
     base::WeakPtr<RenderThreadImpl> render_thread,
     mojo::PendingReceiver<mojom::ResourceUsageReporter> receiver) {
   mojo::MakeSelfOwnedReceiver(
       std::make_unique<ResourceUsageReporterImpl>(std::move(render_thread)),
       std::move(receiver));
 }

 void CreateEmbeddedWorkerWithRenderMainThread(
     scoped_refptr<base::SingleThreadTaskRunner> initiator_task_runner,
     base::WeakPtr<RenderThreadImpl> render_thread,
     mojo::PendingReceiver<blink::mojom::EmbeddedWorkerInstanceClient>
         receiver) {
   TRACE_EVENT0("ServiceWorker", "CreateEmbeddedWorkerWithRenderMainThread");
   initiator_task_runner->PostTask(
       FROM_HERE, base::BindOnce(&EmbeddedWorkerInstanceClientImpl::Create,
                                 initiator_task_runner,
                                 render_thread->cors_exempt_header_list(),
                                 std::move(receiver)));
 }

 void CreateEmbeddedWorker(
     scoped_refptr<base::SingleThreadTaskRunner> initiator_task_runner,
     mojo::PendingReceiver<blink::mojom::EmbeddedWorkerInstanceClient>
         receiver) {
   TRACE_EVENT0("ServiceWorker", "CreateEmbeddedWorker");
   // An empty fake list is passed to
   // `EmbeddedWorkerInstanceClientImpl::Create()`. That will be overridden by
   // the actual cors exempt header list in
   // `EmbeddedWorkerInstanceClientImpl::StartWorker()`.
   //
   // TODO(crbug.com/40753993): Remove this fake empty list once we confirmed
   // this approach is fine.
   const std::vector<std::string> fake_cors_exempt_header_list;
   initiator_task_runner->PostTask(
       FROM_HERE,
       base::BindOnce(&EmbeddedWorkerInstanceClientImpl::Create,
                      initiator_task_runner, fake_cors_exempt_header_list,
                      std::move(receiver)));
 }
 }  // namespace

 void ExposeRendererInterfacesToBrowser(
     base::WeakPtr<RenderThreadImpl> render_thread,
     mojo::BinderMap* binders) {
   DCHECK(render_thread);

   binders->Add<blink::mojom::SharedWorkerFactory>(
       base::BindRepeating(&SharedWorkerFactoryImpl::Create),
       base::SingleThreadTaskRunner::GetCurrentDefault());
   binders->Add<mojom::ResourceUsageReporter>(
       base::BindRepeating(&CreateResourceUsageReporter, render_thread),
       base::SingleThreadTaskRunner::GetCurrentDefault());
 #if BUILDFLAG(IS_ANDROID)
   binders->Add<auction_worklet::mojom::AuctionWorkletService>(
       base::BindRepeating(
           &auction_worklet::AuctionWorkletServiceImpl::CreateForRenderer),
       base::SingleThreadTaskRunner::GetCurrentDefault());
 #endif

   auto task_runner_for_service_worker_startup =
       base::ThreadPool::CreateSingleThreadTaskRunner(
           {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
   // TODO(crbug.com/40753993): Remove the feature flag and
   // `CreateEmbeddedWorkerWithRenderMainThread()` once we confirmed this
   // approach is fine.
   //
   // The kServiceWorkerAvoidMainThreadForInitialization feature flag is the
   // experimental flag to avoid the additional thread hop over the main thread
   // for the ServiceWorker initialization. Currently it's on the main thread as
   // CreateEmbeddedWorker accesses `cors_exempt_header_list` from
   // `render_thread`. When this feature flag is enabled, binds on
   // `task_runner_for_service_worker_startup` instead of the main thread, so
   // startup isn't blocked on the main thread.
   if (base::FeatureList::IsEnabled(
           features::kServiceWorkerAvoidMainThreadForInitialization)) {
     binders->Add<blink::mojom::EmbeddedWorkerInstanceClient>(
         base::BindRepeating(&CreateEmbeddedWorker,
                             task_runner_for_service_worker_startup),
         task_runner_for_service_worker_startup);
   } else {
     binders->Add<blink::mojom::EmbeddedWorkerInstanceClient>(
         base::BindRepeating(&CreateEmbeddedWorkerWithRenderMainThread,
                             task_runner_for_service_worker_startup,
                             render_thread),
         base::SingleThreadTaskRunner::GetCurrentDefault());
   }

   GetContentClient()->renderer()->ExposeInterfacesToBrowser(binders);
 }

 }  // namespace content
	// Copyright 2019 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "content/renderer/browser_exposed_renderer_interfaces.h"

	#include <stdint.h>

	#include <memory>
	#include <utility>

	#include "base/feature_list.h"
	#include "base/functional/bind.h"
	#include "base/memory/scoped_refptr.h"
	#include "base/memory/weak_ptr.h"
	#include "base/task/single_thread_task_runner.h"
	#include "base/task/task_runner.h"
	#include "base/task/thread_pool.h"
	#include "base/time/time.h"
	#include "base/trace_event/trace_event.h"
	#include "build/build_config.h"
	#include "content/common/features.h"
	#include "content/common/frame.mojom.h"
	#include "content/public/common/content_client.h"
	#include "content/public/common/resource_usage_reporter.mojom.h"
	#include "content/public/common/resource_usage_reporter_type_converters.h"
	#include "content/public/renderer/content_renderer_client.h"
	#include "content/renderer/render_thread_impl.h"
	#include "content/renderer/service_worker/embedded_worker_instance_client_impl.h"
	#include "content/renderer/worker/shared_worker_factory_impl.h"
	#include "content/services/auction_worklet/auction_worklet_service_impl.h"
	#include "mojo/public/cpp/bindings/binder_map.h"
	#include "mojo/public/cpp/bindings/pending_receiver.h"
	#include "mojo/public/cpp/bindings/self_owned_receiver.h"
	#include "v8/include/v8-isolate.h"
	#include "v8/include/v8-statistics.h"

	namespace content {

	namespace {

	constexpr int kWaitForWorkersStatsTimeoutMS = 20;

	class ResourceUsageReporterImpl : public content::mojom::ResourceUsageReporter {
	public:
	explicit ResourceUsageReporterImpl(base::WeakPtr<RenderThread> thread)
	: thread_(std::move(thread)) {}
	ResourceUsageReporterImpl(const ResourceUsageReporterImpl&) = delete;
	~ResourceUsageReporterImpl() override = default;

	ResourceUsageReporterImpl& operator=(const ResourceUsageReporterImpl&) =
	delete;

	private:
	static void CollectOnWorkerThread(
	const scoped_refptr<base::TaskRunner>& master,
	base::WeakPtr<ResourceUsageReporterImpl> impl) {
	size_t total_bytes = 0;
	size_t used_bytes = 0;
	v8::Isolate* isolate = v8::Isolate::GetCurrent();
	if (isolate) {
	v8::HeapStatistics heap_stats;
	isolate->GetHeapStatistics(&heap_stats);
	total_bytes = heap_stats.total_heap_size();
	used_bytes = heap_stats.used_heap_size();
	}
	master->PostTask(FROM_HERE,
	base::BindOnce(&ResourceUsageReporterImpl::ReceiveStats,
	impl, total_bytes, used_bytes));
	}

	void ReceiveStats(size_t total_bytes, size_t used_bytes) {
	usage_data_->v8_bytes_allocated += total_bytes;
	usage_data_->v8_bytes_used += used_bytes;
	workers_to_go_--;
	if (!workers_to_go_)
	SendResults();
	}

	void SendResults() {
	if (!callback_.is_null())
	std::move(callback_).Run(std::move(usage_data_));
	callback_.Reset();
	weak_factory_.InvalidateWeakPtrs();
	workers_to_go_ = 0;
	}

	void GetUsageData(GetUsageDataCallback callback) override {
	DCHECK(callback_.is_null());
	weak_factory_.InvalidateWeakPtrs();
	usage_data_ = mojom::ResourceUsageData::New();
	usage_data_->reports_v8_stats = true;
	callback_ = std::move(callback);

	// Since it is not safe to call any Blink or V8 functions until Blink has
	// been initialized (which also initializes V8), early out and send 0 back
	// for all resources.
	if (!thread_) {
	SendResults();
	return;
	}

	blink::WebCacheResourceTypeStats stats;
	blink::WebCache::GetResourceTypeStats(&stats);
	usage_data_->web_cache_stats = mojom::ResourceTypeStats::From(stats);

	v8::Isolate* isolate = v8::Isolate::GetCurrent();
	if (isolate) {
	v8::HeapStatistics heap_stats;
	isolate->GetHeapStatistics(&heap_stats);
	usage_data_->v8_bytes_allocated = heap_stats.total_heap_size();
	usage_data_->v8_bytes_used = heap_stats.used_heap_size();
	}
	base::RepeatingClosure collect =
	base::BindRepeating(&ResourceUsageReporterImpl::CollectOnWorkerThread,
	base::SingleThreadTaskRunner::GetCurrentDefault(),
	weak_factory_.GetWeakPtr());
	workers_to_go_ =
	RenderThread::Get()->PostTaskToAllWebWorkers(std::move(collect));
	if (workers_to_go_) {
	// The guard task to send out partial stats
	// in case some workers are not responsive.
	base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
	FROM_HERE,
	base::BindOnce(&ResourceUsageReporterImpl::SendResults,
	weak_factory_.GetWeakPtr()),
	base::Milliseconds(kWaitForWorkersStatsTimeoutMS));
	} else {
	// No worker threads so just send out the main thread data right away.
	SendResults();
	}
	}

	const base::WeakPtr<RenderThread> thread_;
	mojom::ResourceUsageDataPtr usage_data_;
	GetUsageDataCallback callback_;
	int workers_to_go_ = 0;

	base::WeakPtrFactory<ResourceUsageReporterImpl> weak_factory_{this};
	};

	void CreateResourceUsageReporter(
	base::WeakPtr<RenderThreadImpl> render_thread,
	mojo::PendingReceiver<mojom::ResourceUsageReporter> receiver) {
	mojo::MakeSelfOwnedReceiver(
	std::make_unique<ResourceUsageReporterImpl>(std::move(render_thread)),
	std::move(receiver));
	}

	void CreateEmbeddedWorkerWithRenderMainThread(
	scoped_refptr<base::SingleThreadTaskRunner> initiator_task_runner,
	base::WeakPtr<RenderThreadImpl> render_thread,
	mojo::PendingReceiver<blink::mojom::EmbeddedWorkerInstanceClient>
	receiver) {
	TRACE_EVENT0("ServiceWorker", "CreateEmbeddedWorkerWithRenderMainThread");
	initiator_task_runner->PostTask(
	FROM_HERE, base::BindOnce(&EmbeddedWorkerInstanceClientImpl::Create,
	initiator_task_runner,
	render_thread->cors_exempt_header_list(),
	std::move(receiver)));
	}

	void CreateEmbeddedWorker(
	scoped_refptr<base::SingleThreadTaskRunner> initiator_task_runner,
	mojo::PendingReceiver<blink::mojom::EmbeddedWorkerInstanceClient>
	receiver) {
	TRACE_EVENT0("ServiceWorker", "CreateEmbeddedWorker");
	// An empty fake list is passed to
	// `EmbeddedWorkerInstanceClientImpl::Create()`. That will be overridden by
	// the actual cors exempt header list in
	// `EmbeddedWorkerInstanceClientImpl::StartWorker()`.
	//
	// TODO(crbug.com/40753993): Remove this fake empty list once we confirmed
	// this approach is fine.
	const std::vector<std::string> fake_cors_exempt_header_list;
	initiator_task_runner->PostTask(
	FROM_HERE,
	base::BindOnce(&EmbeddedWorkerInstanceClientImpl::Create,
	initiator_task_runner, fake_cors_exempt_header_list,
	std::move(receiver)));
	}
	} // namespace

	void ExposeRendererInterfacesToBrowser(
	base::WeakPtr<RenderThreadImpl> render_thread,
	mojo::BinderMap* binders) {
	DCHECK(render_thread);

	binders->Add<blink::mojom::SharedWorkerFactory>(
	base::BindRepeating(&SharedWorkerFactoryImpl::Create),
	base::SingleThreadTaskRunner::GetCurrentDefault());
	binders->Add<mojom::ResourceUsageReporter>(
	base::BindRepeating(&CreateResourceUsageReporter, render_thread),
	base::SingleThreadTaskRunner::GetCurrentDefault());
	#if BUILDFLAG(IS_ANDROID)
	binders->Add<auction_worklet::mojom::AuctionWorkletService>(
	base::BindRepeating(
	&auction_worklet::AuctionWorkletServiceImpl::CreateForRenderer),
	base::SingleThreadTaskRunner::GetCurrentDefault());
	#endif

	auto task_runner_for_service_worker_startup =
	base::ThreadPool::CreateSingleThreadTaskRunner(
	{base::MayBlock(), base::TaskPriority::USER_BLOCKING,
	base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
	// TODO(crbug.com/40753993): Remove the feature flag and
	// `CreateEmbeddedWorkerWithRenderMainThread()` once we confirmed this
	// approach is fine.
	//
	// The kServiceWorkerAvoidMainThreadForInitialization feature flag is the
	// experimental flag to avoid the additional thread hop over the main thread
	// for the ServiceWorker initialization. Currently it's on the main thread as
	// CreateEmbeddedWorker accesses `cors_exempt_header_list` from
	// `render_thread`. When this feature flag is enabled, binds on
	// `task_runner_for_service_worker_startup` instead of the main thread, so
	// startup isn't blocked on the main thread.
	if (base::FeatureList::IsEnabled(
	features::kServiceWorkerAvoidMainThreadForInitialization)) {
	binders->Add<blink::mojom::EmbeddedWorkerInstanceClient>(
	base::BindRepeating(&CreateEmbeddedWorker,
	task_runner_for_service_worker_startup),
	task_runner_for_service_worker_startup);
	} else {
	binders->Add<blink::mojom::EmbeddedWorkerInstanceClient>(
	base::BindRepeating(&CreateEmbeddedWorkerWithRenderMainThread,
	task_runner_for_service_worker_startup,
	render_thread),
	base::SingleThreadTaskRunner::GetCurrentDefault());
	}

	GetContentClient()->renderer()->ExposeInterfacesToBrowser(binders);
	}

	} // namespace content