chromium/src/third_party/blink/renderer/core/content_capture/content_capture_task.cc - manifest_repos/chromium_src - Git at Google

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

 #include "third_party/blink/renderer/core/content_capture/content_capture_task.h"

 #include <cmath>

 #include "base/auto_reset.h"
 #include "base/feature_list.h"
 #include "cc/trees/layer_tree_host.h"
 #include "third_party/blink/public/common/features.h"
 #include "third_party/blink/public/web/web_content_capture_client.h"
 #include "third_party/blink/public/web/web_content_holder.h"
 #include "third_party/blink/renderer/core/dom/dom_node_ids.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/frame/local_frame_client.h"
 #include "third_party/blink/renderer/core/layout/layout_text.h"
 #include "third_party/blink/renderer/core/paint/paint_layer.h"
 #include "third_party/blink/renderer/platform/graphics/graphics_layer.h"
 #include "third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h"
 #include "third_party/blink/renderer/platform/wtf/functional.h"

 namespace blink {

 ContentCaptureTask::TaskDelay::TaskDelay(
     const base::TimeDelta& task_short_delay,
     const base::TimeDelta& task_long_delay)
     : task_short_delay_(task_short_delay), task_long_delay_(task_long_delay) {}

 base::TimeDelta ContentCaptureTask::TaskDelay::ResetAndGetInitialDelay() {
   delay_exponent_ = 0;
   return task_short_delay_;
 }

 base::TimeDelta ContentCaptureTask::TaskDelay::GetNextTaskDelay() const {
   return base::TimeDelta::FromMilliseconds(task_short_delay_.InMilliseconds() *
                                            (1 << delay_exponent_));
 }

 void ContentCaptureTask::TaskDelay::IncreaseDelayExponent() {
   // Increases the delay up to 128s.
   if (delay_exponent_ < 8)
     ++delay_exponent_;
 }

 ContentCaptureTask::ContentCaptureTask(LocalFrame& local_frame_root,
                                        TaskSession& task_session)
     : local_frame_root_(&local_frame_root),
       task_session_(&task_session),
       delay_task_(
           local_frame_root_->GetTaskRunner(TaskType::kInternalContentCapture),
           this,
           &ContentCaptureTask::Run) {
   base::TimeDelta task_short_delay;
   base::TimeDelta task_long_delay;

   local_frame_root.Client()
       ->GetWebContentCaptureClient()
       ->GetTaskTimingParameters(task_short_delay, task_long_delay);
   task_delay_ = std::make_unique<TaskDelay>(task_short_delay, task_long_delay);

   // The histogram is all about time, just disable it if high resolution isn't
   // supported.
   if (base::TimeTicks::IsHighResolution()) {
     histogram_reporter_ =
         base::MakeRefCounted<ContentCaptureTaskHistogramReporter>();
     task_session_->SetSentNodeCountCallback(
         WTF::BindRepeating(&ContentCaptureTaskHistogramReporter::
                                RecordsSentContentCountPerDocument,
                            histogram_reporter_));
   }
 }

 ContentCaptureTask::~ContentCaptureTask() = default;

 void ContentCaptureTask::Shutdown() {
   DCHECK(local_frame_root_);
   local_frame_root_ = nullptr;
   CancelTask();
 }

 bool ContentCaptureTask::CaptureContent(Vector<cc::NodeInfo>& data) {
   if (captured_content_for_testing_) {
     data = captured_content_for_testing_.value();
     return true;
   }
   // Because this is called from a different task, the frame may be in any
   // lifecycle step so we need to early-out in many cases.
   if (const auto* root_frame_view = local_frame_root_->View()) {
     if (const auto* cc_layer = root_frame_view->RootCcLayer()) {
       if (auto* layer_tree_host = cc_layer->layer_tree_host()) {
         std::vector<cc::NodeInfo> content;
         if (layer_tree_host->CaptureContent(&content)) {
           for (auto c : content)
             data.push_back(std::move(c));
           return true;
         }
         return false;
       }
     }
   }
   return false;
 }

 bool ContentCaptureTask::CaptureContent() {
   DCHECK(task_session_);
   Vector<cc::NodeInfo> buffer;
   if (histogram_reporter_)
     histogram_reporter_->OnCaptureContentStarted();
   bool result = CaptureContent(buffer);
   if (!buffer.IsEmpty())
     task_session_->SetCapturedContent(buffer);
   if (histogram_reporter_)
     histogram_reporter_->OnCaptureContentEnded(buffer.size());
   return result;
 }

 void ContentCaptureTask::SendContent(
     TaskSession::DocumentSession& doc_session) {
   auto* document = doc_session.GetDocument();
   DCHECK(document);
   auto* client = GetWebContentCaptureClient(*document);
   DCHECK(client);

   if (histogram_reporter_)
     histogram_reporter_->OnSendContentStarted();
   WebVector<WebContentHolder> content_batch;
   content_batch.reserve(kBatchSize);
   // Only send changed content after the new content was sent.
   bool sending_changed_content = !doc_session.HasUnsentCapturedContent();
   while (content_batch.size() < kBatchSize) {
     ContentHolder* holder;
     if (sending_changed_content)
       holder = doc_session.GetNextChangedNode();
     else
       holder = doc_session.GetNextUnsentNode();
     if (!holder)
       break;
     content_batch.emplace_back(WebContentHolder(*holder));
   }
   if (!content_batch.empty()) {
     if (sending_changed_content) {
       client->DidUpdateContent(content_batch);
     } else {
       client->DidCaptureContent(content_batch, !doc_session.FirstDataHasSent());
       doc_session.SetFirstDataHasSent();
     }
   }
   if (histogram_reporter_)
     histogram_reporter_->OnSendContentEnded(content_batch.size());
 }

 WebContentCaptureClient* ContentCaptureTask::GetWebContentCaptureClient(
     const Document& document) {
   if (auto* frame = document.GetFrame())
     return frame->Client()->GetWebContentCaptureClient();
   return nullptr;
 }

 bool ContentCaptureTask::ProcessSession() {
   DCHECK(task_session_);
   while (auto* document_session =
              task_session_->GetNextUnsentDocumentSession()) {
     if (!ProcessDocumentSession(*document_session))
       return false;
     if (ShouldPause())
       return !task_session_->HasUnsentData();
   }
   return true;
 }

 bool ContentCaptureTask::ProcessDocumentSession(
     TaskSession::DocumentSession& doc_session) {
   // If no client, we don't need to send it at all.
   auto* content_capture_client =
       GetWebContentCaptureClient(*doc_session.GetDocument());
   if (!content_capture_client) {
     doc_session.Reset();
     return true;
   }

   while (doc_session.HasUnsentCapturedContent() ||
          doc_session.HasUnsentChangedContent()) {
     SendContent(doc_session);
     if (ShouldPause()) {
       return !doc_session.HasUnsentData();
     }
   }
   // Sent the detached nodes.
   if (doc_session.HasUnsentDetachedNodes())
     content_capture_client->DidRemoveContent(doc_session.MoveDetachedNodes());
   DCHECK(!doc_session.HasUnsentData());
   return true;
 }

 bool ContentCaptureTask::RunInternal() {
   base::AutoReset<TaskState> state(&task_state_, TaskState::kProcessRetryTask);
   // Already shutdown.
   if (!local_frame_root_)
     return true;

   do {
     switch (task_state_) {
       case TaskState::kProcessRetryTask:
         if (task_session_->HasUnsentData()) {
           if (!ProcessSession())
             return false;
         }
         task_state_ = TaskState::kCaptureContent;
         break;
       case TaskState::kCaptureContent:
         if (!has_content_change_)
           return true;
         if (!CaptureContent()) {
           // Don't schedule task again in this case.
           return true;
         }
         has_content_change_ = false;
         if (!task_session_->HasUnsentData())
           return true;

         task_state_ = TaskState::kProcessCurrentSession;
         break;
       case TaskState::kProcessCurrentSession:
         return ProcessSession();
       default:
         return true;
     }
   } while (!ShouldPause());
   return false;
 }

 void ContentCaptureTask::Run(TimerBase*) {
   TRACE_EVENT0("content_capture", "RunTask");
   task_delay_->IncreaseDelayExponent();
   if (histogram_reporter_)
     histogram_reporter_->OnTaskRun();
   bool completed = RunInternal();
   if (!completed) {
     ScheduleInternal(ScheduleReason::kRetryTask);
   }
   if (histogram_reporter_ &&
       (completed || task_state_ == TaskState::kCaptureContent)) {
     // The current capture session ends if the task indicates it completed or
     // is about to capture the new changes.
     histogram_reporter_->OnAllCapturedContentSent();
   }
 }

 base::TimeDelta ContentCaptureTask::GetAndAdjustDelay(ScheduleReason reason) {
   bool user_activated_delay_enabled =
       base::FeatureList::IsEnabled(features::kContentCaptureUserActivatedDelay);
   switch (reason) {
     case ScheduleReason::kFirstContentChange:
     case ScheduleReason::kScrolling:
     case ScheduleReason::kRetryTask:
       return user_activated_delay_enabled
                  ? task_delay_->ResetAndGetInitialDelay()
                  : task_delay_->task_short_delay();
     case ScheduleReason::kUserActivatedContentChange:
       return user_activated_delay_enabled
                  ? task_delay_->ResetAndGetInitialDelay()
                  : task_delay_->task_long_delay();
     case ScheduleReason::kNonUserActivatedContentChange:
       return user_activated_delay_enabled ? task_delay_->GetNextTaskDelay()
                                           : task_delay_->task_long_delay();
   }
 }

 void ContentCaptureTask::ScheduleInternal(ScheduleReason reason) {
   DCHECK(local_frame_root_);
   base::TimeDelta delay = GetAndAdjustDelay(reason);

   // Return if the current task is about to run soon.
   if (delay_task_.IsActive() && delay_task_.NextFireInterval() < delay) {
     return;
   }

   if (delay_task_.IsActive())
     delay_task_.Stop();

   delay_task_.StartOneShot(delay, FROM_HERE);
   TRACE_EVENT_INSTANT1("content_capture", "ScheduleTask",
                        TRACE_EVENT_SCOPE_THREAD, "reason", reason);
   if (histogram_reporter_) {
     histogram_reporter_->OnTaskScheduled(/* record_task_delay = */ reason !=
                                          ScheduleReason::kRetryTask);
   }
 }

 void ContentCaptureTask::Schedule(ScheduleReason reason) {
   DCHECK(local_frame_root_);
   has_content_change_ = true;
   if (histogram_reporter_)
     histogram_reporter_->OnContentChanged();
   ScheduleInternal(reason);
 }

 bool ContentCaptureTask::ShouldPause() {
   if (task_stop_for_testing_) {
     return task_state_ == task_stop_for_testing_.value();
   }
   return ThreadScheduler::Current()->ShouldYieldForHighPriorityWork();
 }

 void ContentCaptureTask::CancelTask() {
   if (delay_task_.IsActive())
     delay_task_.Stop();
 }
 void ContentCaptureTask::ClearDocumentSessionsForTesting() {
   task_session_->ClearDocumentSessionsForTesting();
 }

 base::TimeDelta ContentCaptureTask::GetTaskNextFireIntervalForTesting() const {
   return delay_task_.IsActive() ? delay_task_.NextFireInterval()
                                 : base::TimeDelta();
 }

 void ContentCaptureTask::CancelTaskForTesting() {
   CancelTask();
 }

 void ContentCaptureTask::Trace(Visitor* visitor) const {
   visitor->Trace(local_frame_root_);
   visitor->Trace(task_session_);
   visitor->Trace(delay_task_);
 }

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

	#include "third_party/blink/renderer/core/content_capture/content_capture_task.h"

	#include <cmath>

	#include "base/auto_reset.h"
	#include "base/feature_list.h"
	#include "cc/trees/layer_tree_host.h"
	#include "third_party/blink/public/common/features.h"
	#include "third_party/blink/public/web/web_content_capture_client.h"
	#include "third_party/blink/public/web/web_content_holder.h"
	#include "third_party/blink/renderer/core/dom/dom_node_ids.h"
	#include "third_party/blink/renderer/core/frame/local_frame.h"
	#include "third_party/blink/renderer/core/frame/local_frame_client.h"
	#include "third_party/blink/renderer/core/layout/layout_text.h"
	#include "third_party/blink/renderer/core/paint/paint_layer.h"
	#include "third_party/blink/renderer/platform/graphics/graphics_layer.h"
	#include "third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h"
	#include "third_party/blink/renderer/platform/wtf/functional.h"

	namespace blink {

	ContentCaptureTask::TaskDelay::TaskDelay(
	const base::TimeDelta& task_short_delay,
	const base::TimeDelta& task_long_delay)
	: task_short_delay_(task_short_delay), task_long_delay_(task_long_delay) {}

	base::TimeDelta ContentCaptureTask::TaskDelay::ResetAndGetInitialDelay() {
	delay_exponent_ = 0;
	return task_short_delay_;
	}

	base::TimeDelta ContentCaptureTask::TaskDelay::GetNextTaskDelay() const {
	return base::TimeDelta::FromMilliseconds(task_short_delay_.InMilliseconds() *
	(1 << delay_exponent_));
	}

	void ContentCaptureTask::TaskDelay::IncreaseDelayExponent() {
	// Increases the delay up to 128s.
	if (delay_exponent_ < 8)
	++delay_exponent_;
	}

	ContentCaptureTask::ContentCaptureTask(LocalFrame& local_frame_root,
	TaskSession& task_session)
	: local_frame_root_(&local_frame_root),
	task_session_(&task_session),
	delay_task_(
	local_frame_root_->GetTaskRunner(TaskType::kInternalContentCapture),
	this,
	&ContentCaptureTask::Run) {
	base::TimeDelta task_short_delay;
	base::TimeDelta task_long_delay;

	local_frame_root.Client()
	->GetWebContentCaptureClient()
	->GetTaskTimingParameters(task_short_delay, task_long_delay);
	task_delay_ = std::make_unique<TaskDelay>(task_short_delay, task_long_delay);

	// The histogram is all about time, just disable it if high resolution isn't
	// supported.
	if (base::TimeTicks::IsHighResolution()) {
	histogram_reporter_ =
	base::MakeRefCounted<ContentCaptureTaskHistogramReporter>();
	task_session_->SetSentNodeCountCallback(
	WTF::BindRepeating(&ContentCaptureTaskHistogramReporter::
	RecordsSentContentCountPerDocument,
	histogram_reporter_));
	}
	}

	ContentCaptureTask::~ContentCaptureTask() = default;

	void ContentCaptureTask::Shutdown() {
	DCHECK(local_frame_root_);
	local_frame_root_ = nullptr;
	CancelTask();
	}

	bool ContentCaptureTask::CaptureContent(Vector<cc::NodeInfo>& data) {
	if (captured_content_for_testing_) {
	data = captured_content_for_testing_.value();
	return true;
	}
	// Because this is called from a different task, the frame may be in any
	// lifecycle step so we need to early-out in many cases.
	if (const auto* root_frame_view = local_frame_root_->View()) {
	if (const auto* cc_layer = root_frame_view->RootCcLayer()) {
	if (auto* layer_tree_host = cc_layer->layer_tree_host()) {
	std::vector<cc::NodeInfo> content;
	if (layer_tree_host->CaptureContent(&content)) {
	for (auto c : content)
	data.push_back(std::move(c));
	return true;
	}
	return false;
	}
	}
	}
	return false;
	}

	bool ContentCaptureTask::CaptureContent() {
	DCHECK(task_session_);
	Vector<cc::NodeInfo> buffer;
	if (histogram_reporter_)
	histogram_reporter_->OnCaptureContentStarted();
	bool result = CaptureContent(buffer);
	if (!buffer.IsEmpty())
	task_session_->SetCapturedContent(buffer);
	if (histogram_reporter_)
	histogram_reporter_->OnCaptureContentEnded(buffer.size());
	return result;
	}

	void ContentCaptureTask::SendContent(
	TaskSession::DocumentSession& doc_session) {
	auto* document = doc_session.GetDocument();
	DCHECK(document);
	auto* client = GetWebContentCaptureClient(*document);
	DCHECK(client);

	if (histogram_reporter_)
	histogram_reporter_->OnSendContentStarted();
	WebVector<WebContentHolder> content_batch;
	content_batch.reserve(kBatchSize);
	// Only send changed content after the new content was sent.
	bool sending_changed_content = !doc_session.HasUnsentCapturedContent();
	while (content_batch.size() < kBatchSize) {
	ContentHolder* holder;
	if (sending_changed_content)
	holder = doc_session.GetNextChangedNode();
	else
	holder = doc_session.GetNextUnsentNode();
	if (!holder)
	break;
	content_batch.emplace_back(WebContentHolder(*holder));
	}
	if (!content_batch.empty()) {
	if (sending_changed_content) {
	client->DidUpdateContent(content_batch);
	} else {
	client->DidCaptureContent(content_batch, !doc_session.FirstDataHasSent());
	doc_session.SetFirstDataHasSent();
	}
	}
	if (histogram_reporter_)
	histogram_reporter_->OnSendContentEnded(content_batch.size());
	}

	WebContentCaptureClient* ContentCaptureTask::GetWebContentCaptureClient(
	const Document& document) {
	if (auto* frame = document.GetFrame())
	return frame->Client()->GetWebContentCaptureClient();
	return nullptr;
	}

	bool ContentCaptureTask::ProcessSession() {
	DCHECK(task_session_);
	while (auto* document_session =
	task_session_->GetNextUnsentDocumentSession()) {
	if (!ProcessDocumentSession(*document_session))
	return false;
	if (ShouldPause())
	return !task_session_->HasUnsentData();
	}
	return true;
	}

	bool ContentCaptureTask::ProcessDocumentSession(
	TaskSession::DocumentSession& doc_session) {
	// If no client, we don't need to send it at all.
	auto* content_capture_client =
	GetWebContentCaptureClient(*doc_session.GetDocument());
	if (!content_capture_client) {
	doc_session.Reset();
	return true;
	}

	while (doc_session.HasUnsentCapturedContent() \|\|
	doc_session.HasUnsentChangedContent()) {
	SendContent(doc_session);
	if (ShouldPause()) {
	return !doc_session.HasUnsentData();
	}
	}
	// Sent the detached nodes.
	if (doc_session.HasUnsentDetachedNodes())
	content_capture_client->DidRemoveContent(doc_session.MoveDetachedNodes());
	DCHECK(!doc_session.HasUnsentData());
	return true;
	}

	bool ContentCaptureTask::RunInternal() {
	base::AutoReset<TaskState> state(&task_state_, TaskState::kProcessRetryTask);
	// Already shutdown.
	if (!local_frame_root_)
	return true;

	do {
	switch (task_state_) {
	case TaskState::kProcessRetryTask:
	if (task_session_->HasUnsentData()) {
	if (!ProcessSession())
	return false;
	}
	task_state_ = TaskState::kCaptureContent;
	break;
	case TaskState::kCaptureContent:
	if (!has_content_change_)
	return true;
	if (!CaptureContent()) {
	// Don't schedule task again in this case.
	return true;
	}
	has_content_change_ = false;
	if (!task_session_->HasUnsentData())
	return true;

	task_state_ = TaskState::kProcessCurrentSession;
	break;
	case TaskState::kProcessCurrentSession:
	return ProcessSession();
	default:
	return true;
	}
	} while (!ShouldPause());
	return false;
	}

	void ContentCaptureTask::Run(TimerBase*) {
	TRACE_EVENT0("content_capture", "RunTask");
	task_delay_->IncreaseDelayExponent();
	if (histogram_reporter_)
	histogram_reporter_->OnTaskRun();
	bool completed = RunInternal();
	if (!completed) {
	ScheduleInternal(ScheduleReason::kRetryTask);
	}
	if (histogram_reporter_ &&
	(completed \|\| task_state_ == TaskState::kCaptureContent)) {
	// The current capture session ends if the task indicates it completed or
	// is about to capture the new changes.
	histogram_reporter_->OnAllCapturedContentSent();
	}
	}

	base::TimeDelta ContentCaptureTask::GetAndAdjustDelay(ScheduleReason reason) {
	bool user_activated_delay_enabled =
	base::FeatureList::IsEnabled(features::kContentCaptureUserActivatedDelay);
	switch (reason) {
	case ScheduleReason::kFirstContentChange:
	case ScheduleReason::kScrolling:
	case ScheduleReason::kRetryTask:
	return user_activated_delay_enabled
	? task_delay_->ResetAndGetInitialDelay()
	: task_delay_->task_short_delay();
	case ScheduleReason::kUserActivatedContentChange:
	return user_activated_delay_enabled
	? task_delay_->ResetAndGetInitialDelay()
	: task_delay_->task_long_delay();
	case ScheduleReason::kNonUserActivatedContentChange:
	return user_activated_delay_enabled ? task_delay_->GetNextTaskDelay()
	: task_delay_->task_long_delay();
	}
	}

	void ContentCaptureTask::ScheduleInternal(ScheduleReason reason) {
	DCHECK(local_frame_root_);
	base::TimeDelta delay = GetAndAdjustDelay(reason);

	// Return if the current task is about to run soon.
	if (delay_task_.IsActive() && delay_task_.NextFireInterval() < delay) {
	return;
	}

	if (delay_task_.IsActive())
	delay_task_.Stop();

	delay_task_.StartOneShot(delay, FROM_HERE);
	TRACE_EVENT_INSTANT1("content_capture", "ScheduleTask",
	TRACE_EVENT_SCOPE_THREAD, "reason", reason);
	if (histogram_reporter_) {
	histogram_reporter_->OnTaskScheduled(/* record_task_delay = */ reason !=
	ScheduleReason::kRetryTask);
	}
	}

	void ContentCaptureTask::Schedule(ScheduleReason reason) {
	DCHECK(local_frame_root_);
	has_content_change_ = true;
	if (histogram_reporter_)
	histogram_reporter_->OnContentChanged();
	ScheduleInternal(reason);
	}

	bool ContentCaptureTask::ShouldPause() {
	if (task_stop_for_testing_) {
	return task_state_ == task_stop_for_testing_.value();
	}
	return ThreadScheduler::Current()->ShouldYieldForHighPriorityWork();
	}

	void ContentCaptureTask::CancelTask() {
	if (delay_task_.IsActive())
	delay_task_.Stop();
	}
	void ContentCaptureTask::ClearDocumentSessionsForTesting() {
	task_session_->ClearDocumentSessionsForTesting();
	}

	base::TimeDelta ContentCaptureTask::GetTaskNextFireIntervalForTesting() const {
	return delay_task_.IsActive() ? delay_task_.NextFireInterval()
	: base::TimeDelta();
	}

	void ContentCaptureTask::CancelTaskForTesting() {
	CancelTask();
	}

	void ContentCaptureTask::Trace(Visitor* visitor) const {
	visitor->Trace(local_frame_root_);
	visitor->Trace(task_session_);
	visitor->Trace(delay_task_);
	}

	} // namespace blink