| // Copyright 2022 The Chromium Authors | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "components/user_notes/browser/user_note_instance.h" | |
| #include "components/user_notes/browser/user_note_manager.h" | |
| #include "components/user_notes/model/user_note_target.h" | |
| namespace user_notes { | |
| UserNoteInstance::UserNoteInstance(base::SafeRef<UserNote> model, | |
| UserNoteManager* parent_manager, | |
| PassKey pass_key) | |
| : model_(std::move(model)), | |
| parent_manager_(parent_manager), | |
| receiver_(this) {} | |
| UserNoteInstance::UserNoteInstance(base::SafeRef<UserNote> model, | |
| UserNoteManager* parent_manager) | |
| : UserNoteInstance(std::move(model), parent_manager, PassKey()) {} | |
| // static | |
| std::unique_ptr<UserNoteInstance> UserNoteInstance::Create( | |
| base::SafeRef<UserNote> model, | |
| UserNoteManager* parent_manager) { | |
| return std::make_unique<UserNoteInstance>(std::move(model), parent_manager, | |
| PassKey()); | |
| } | |
| UserNoteInstance::~UserNoteInstance() = default; | |
| bool UserNoteInstance::IsDetached() const { | |
| return finished_attachment_ && rect_.IsEmpty() && | |
| model_->target().type() == UserNoteTarget::TargetType::kPageText; | |
| } | |
| void UserNoteInstance::BindToHighlight( | |
| mojo::PendingReceiver<blink::mojom::AnnotationAgentHost> host_receiver, | |
| mojo::PendingRemote<blink::mojom::AnnotationAgent> agent_remote, | |
| AttachmentFinishedCallback callback) { | |
| DCHECK_EQ(model_->target().type(), UserNoteTarget::TargetType::kPageText); | |
| DCHECK(!agent_.is_bound()); | |
| DCHECK(!receiver_.is_bound()); | |
| DCHECK(agent_remote.is_valid()); | |
| DCHECK(host_receiver.is_valid()); | |
| did_finish_attachment_callback_ = std::move(callback); | |
| agent_.Bind(std::move(agent_remote)); | |
| // base::Unretained since note instances are always destroyed before the | |
| // manager (the manager's destructor explicitly destroys them). | |
| agent_.set_disconnect_handler( | |
| base::BindOnce(&UserNoteManager::RemoveNote, | |
| base::Unretained(parent_manager_), model_->id())); | |
| receiver_.Bind(std::move(host_receiver)); | |
| } | |
| void UserNoteInstance::InitializeHighlightIfNeeded( | |
| AttachmentFinishedCallback callback) { | |
| // If the UserNoteInstance was instantiated to create a new note, the | |
| // highlight will already be initialized in the renderer. In this case, | |
| // BindToHighlight must already have been called and so a `callback` must not | |
| // be passed to this method since a callback was already passed in | |
| // BindToHighlight. | |
| if (agent_.is_bound()) { | |
| DCHECK(receiver_.is_bound()); | |
| DCHECK(!callback); | |
| DCHECK_EQ(model_->target().type(), UserNoteTarget::TargetType::kPageText); | |
| DCHECK_EQ(finished_attachment_, did_finish_attachment_callback_.is_null()); | |
| return; | |
| } | |
| DCHECK(callback); | |
| switch (model_->target().type()) { | |
| case UserNoteTarget::TargetType::kPage: { | |
| // Page-level notes are not associated with text in the page, so there is | |
| // no highlight to create on the renderer side. Also, this instance may | |
| // already have been initialized as part of generating a new note. In | |
| // these cases, do nothing. | |
| std::move(callback).Run(); | |
| } break; | |
| case UserNoteTarget::TargetType::kPageText: { | |
| DCHECK(!did_finish_attachment_callback_); | |
| did_finish_attachment_callback_ = std::move(callback); | |
| InitializeHighlightInternal(); | |
| } break; | |
| } | |
| } | |
| void UserNoteInstance::OnNoteSelected() { | |
| if (!agent_) | |
| return; | |
| agent_->ScrollIntoView(); | |
| } | |
| void UserNoteInstance::DidFinishAttachment(const gfx::Rect& rect) { | |
| finished_attachment_ = true; | |
| rect_ = rect; | |
| if (did_finish_attachment_callback_) | |
| std::move(did_finish_attachment_callback_).Run(); | |
| } | |
| void UserNoteInstance::OnWebHighlightFocused() { | |
| parent_manager_->OnWebHighlightFocused(model_->id()); | |
| } | |
| void UserNoteInstance::OnNoteDetached() { | |
| rect_ = gfx::Rect(); | |
| DCHECK(IsDetached()); | |
| // TODO(gujen): Notify the service so it can invalidate the UI. | |
| } | |
| void UserNoteInstance::InitializeHighlightInternal() { | |
| DCHECK_EQ(model_->target().type(), UserNoteTarget::TargetType::kPageText); | |
| parent_manager_->note_agent_container()->CreateAgent( | |
| receiver_.BindNewPipeAndPassRemote(), agent_.BindNewPipeAndPassReceiver(), | |
| blink::mojom::AnnotationType::kUserNote, model_->target().selector()); | |
| // Set a disconnect handler because the renderer can close the pipe at any | |
| // moment to signal that the highlight has been removed from the page. It's ok | |
| // to use base::Unretained here because the note instances are always | |
| // destroyed before the manager (the manager's destructor explicitly destroys | |
| // them). | |
| agent_.set_disconnect_handler( | |
| base::BindOnce(&UserNoteManager::RemoveNote, | |
| base::Unretained(parent_manager_), model_->id())); | |
| } | |
| } // namespace user_notes |