// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/clipboard/clipboard_history_controller_impl.h"
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <vector>
#include "ash/accelerators/accelerator_controller_impl.h"
#include "ash/clipboard/clipboard_history_controller_delegate.h"
#include "ash/clipboard/clipboard_history_item.h"
#include "ash/clipboard/clipboard_history_menu_model_adapter.h"
#include "ash/clipboard/clipboard_history_resource_manager.h"
#include "ash/clipboard/clipboard_history_url_title_fetcher.h"
#include "ash/clipboard/clipboard_history_util.h"
#include "ash/clipboard/clipboard_nudge_constants.h"
#include "ash/clipboard/clipboard_nudge_controller.h"
#include "ash/clipboard/scoped_clipboard_history_pause_impl.h"
#include "ash/constants/ash_features.h"
#include "ash/constants/ash_pref_names.h"
#include "ash/display/display_util.h"
#include "ash/public/cpp/clipboard_image_model_factory.h"
#include "ash/public/cpp/window_tree_host_lookup.h"
#include "ash/session/session_controller_impl.h"
#include "ash/shell.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/style/color_util.h"
#include "ash/wm/window_util.h"
#include "base/barrier_closure.h"
#include "base/check.h"
#include "base/check_is_test.h"
#include "base/check_op.h"
#include "base/functional/bind.h"
#include "base/functional/callback_forward.h"
#include "base/json/values_util.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/user_metrics.h"
#include "base/notreached.h"
#include "base/one_shot_event.h"
#include "base/strings/utf_string_conversions.h"
#include "base/synchronization/lock.h"
#include "base/system/sys_info.h"
#include "base/task/bind_post_task.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/single_thread_task_runner.h"
#include "base/task/thread_pool.h"
#include "base/time/time.h"
#include "base/unguessable_token.h"
#include "chromeos/constants/chromeos_features.h"
#include "chromeos/crosapi/mojom/clipboard_history.mojom.h"
#include "components/prefs/pref_service.h"
#include "ui/aura/window.h"
#include "ui/aura/window_tree_host.h"
#include "ui/base/accelerators/accelerator.h"
#include "ui/base/clipboard/clipboard_data.h"
#include "ui/base/clipboard/clipboard_non_backed.h"
#include "ui/base/clipboard/clipboard_util.h"
#include "ui/base/clipboard/scoped_clipboard_writer.h"
#include "ui/base/data_transfer_policy/data_transfer_endpoint.h"
#include "ui/base/ime/input_method.h"
#include "ui/base/ime/text_input_client.h"
#include "ui/base/models/image_model.h"
#include "ui/base/models/simple_menu_model.h"
#include "ui/base/webui/web_ui_util.h"
#include "ui/color/color_provider_source.h"
#include "ui/events/event.h"
#include "ui/events/event_constants.h"
#include "ui/events/keycodes/keyboard_codes_posix.h"
#include "ui/events/types/event_type.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/views/controls/menu/menu_controller.h"
#if BUILDFLAG(USE_XKBCOMMON)
#include "ui/events/keycodes/xkb_keysym.h"
#include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
#include "ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.h"
#endif
namespace ash {
namespace {
// Encodes `bitmap` and maps the corresponding ClipboardHistoryItem ID, `id, to
// the resulting PNG in `encoded_pngs`. This function should run on a background
// thread.
void EncodeBitmapToPNG(
base::OnceClosure barrier_callback,
std::map<base::UnguessableToken, std::vector<uint8_t>>* const encoded_pngs,
base::UnguessableToken id,
SkBitmap bitmap) {
auto png = ui::clipboard_util::EncodeBitmapToPng(bitmap);
// Don't acquire the lock until after the image encoding has finished.
static base::NoDestructor<base::Lock> map_lock;
base::AutoLock lock(*map_lock);
encoded_pngs->emplace(id, std::move(png));
std::move(barrier_callback).Run();
}
// Returns the clipboard instance for the current thread.
ui::ClipboardNonBacked* GetClipboard() {
auto* clipboard = ui::ClipboardNonBacked::GetForCurrentThread();
DCHECK(clipboard);
return clipboard;
}
// Returns the last active user pref service or `nullptr` if one does not exist.
PrefService* GetLastActiveUserPrefService() {
return Shell::Get()->session_controller()->GetLastActiveUserPrefService();
}
// Returns the time when the menu was last shown for the user associated with
// the last active user pref service, or `std::nullopt` if the menu was not
// previously marked as having been shown.
std::optional<base::Time> GetMenuLastTimeShown() {
if (auto* prefs = GetLastActiveUserPrefService()) {
if (auto* pref = prefs->FindPreference(prefs::kMultipasteMenuLastTimeShown);
pref && !pref->IsDefaultValue()) {
return base::ValueToTime(pref->GetValue());
}
}
return std::nullopt;
}
// Marks the time when the menu was last shown for the user associated with the
// last active user pref service.
void MarkMenuLastTimeShown() {
if (auto* prefs = GetLastActiveUserPrefService()) {
prefs->SetTime(prefs::kMultipasteMenuLastTimeShown, base::Time::Now());
}
}
// Emits a user action indicating that the clipboard history item at menu index
// `command_id` was pasted.
void RecordMenuIndexPastedUserAction(int command_id) {
// Per guidance in user_metrics.h, use string literals for action names.
switch (command_id) {
case 1:
base::RecordAction(
base::UserMetricsAction("Ash_ClipboardHistory_PastedItem1"));
break;
case 2:
base::RecordAction(
base::UserMetricsAction("Ash_ClipboardHistory_PastedItem2"));
break;
case 3:
base::RecordAction(
base::UserMetricsAction("Ash_ClipboardHistory_PastedItem3"));
break;
case 4:
base::RecordAction(
base::UserMetricsAction("Ash_ClipboardHistory_PastedItem4"));
break;
case 5:
base::RecordAction(
base::UserMetricsAction("Ash_ClipboardHistory_PastedItem5"));
break;
default:
NOTREACHED();
}
}
void RecordPasteItemIndex(int index) {
CHECK_GE(index, clipboard_history_util::kFirstItemCommandId);
CHECK_LT(index, clipboard_history_util::kCommandIdBoundary);
// Record the paste item's history list index in a histogram to get a
// distribution of where in the list users paste from.
base::UmaHistogramExactLinear(
"Ash.ClipboardHistory.ContextMenu.MenuOptionSelected", index,
/*exclusive_max=*/clipboard_history_util::kCommandIdBoundary);
// Record the paste item's history list index as a user action to analyze
// usage patterns, e.g., how frequently the same index is pasted multiple
// times in a row.
RecordMenuIndexPastedUserAction(index);
}
#if BUILDFLAG(USE_XKBCOMMON)
// Looks up the DomCode assigned to the keysym. In some edge cases,
// such as Dvorak layout, the original DomCode may be different
// from US standard layout.
ui::DomCode LookUpXkbDomCode(int keysym) {
if (!base::SysInfo::IsRunningOnChromeOS()) {
// On linux-chromeos, stub layout engine is used.
return ui::DomCode::NONE;
}
auto* layout_engine =
ui::KeyboardLayoutEngineManager::GetKeyboardLayoutEngine();
if (!layout_engine) {
return ui::DomCode::NONE;
}
return static_cast<ui::XkbKeyboardLayoutEngine*>(layout_engine)
->GetDomCodeByKeysym(keysym, /*modifiers=*/std::nullopt);
}
#endif
ui::KeyEvent SyntheticCtrlV(ui::EventType type) {
ui::DomCode dom_code = ui::DomCode::NONE;
#if BUILDFLAG(USE_XKBCOMMON)
dom_code = LookUpXkbDomCode(XKB_KEY_v);
#endif
return dom_code == ui::DomCode::NONE
? ui::KeyEvent(type, ui::VKEY_V, ui::EF_CONTROL_DOWN)
: ui::KeyEvent(type, ui::VKEY_V, dom_code, ui::EF_CONTROL_DOWN);
}
ui::KeyEvent SyntheticCtrl(ui::EventType type) {
int flags =
type == ui::EventType::kKeyPressed ? ui::EF_CONTROL_DOWN : ui::EF_NONE;
ui::DomCode dom_code = ui::DomCode::NONE;
#if BUILDFLAG(USE_XKBCOMMON)
dom_code = LookUpXkbDomCode(XKB_KEY_Control_L);
#endif
return dom_code == ui::DomCode::NONE
? ui::KeyEvent(type, ui::VKEY_CONTROL, flags)
: ui::KeyEvent(type, ui::VKEY_CONTROL, dom_code, flags);
}
void SyntheticPaste(
crosapi::mojom::ClipboardHistoryControllerShowSource paste_source) {
auto* host = GetWindowTreeHostForDisplay(
display::Screen::GetScreen()->GetDisplayForNewWindows().id());
CHECK(host);
// Because we do not require the user to release Ctrl+V before selecting a
// clipboard history item to paste, the Ctrl+V event we synthesize below may
// be discarded as a perceived continuation of the long press. Preempt this
// scenario by issuing a Ctrl+V release to ensure that the press and release
// below are handled as an independent paste.
// TODO(http://b/283533126): Replace this workaround with a long-term fix.
if (paste_source == crosapi::mojom::ClipboardHistoryControllerShowSource::
kControlVLongpress) {
ui::KeyEvent v_release = SyntheticCtrlV(ui::EventType::kKeyReleased);
host->DeliverEventToSink(&v_release);
ui::KeyEvent ctrl_release = SyntheticCtrl(ui::EventType::kKeyReleased);
host->DeliverEventToSink(&ctrl_release);
}
ui::KeyEvent ctrl_press = SyntheticCtrl(ui::EventType::kKeyPressed);
host->DeliverEventToSink(&ctrl_press);
ui::KeyEvent v_press = SyntheticCtrlV(ui::EventType::kKeyPressed);
host->DeliverEventToSink(&v_press);
ui::KeyEvent v_release = SyntheticCtrlV(ui::EventType::kKeyReleased);
host->DeliverEventToSink(&v_release);
ui::KeyEvent ctrl_release = SyntheticCtrl(ui::EventType::kKeyReleased);
host->DeliverEventToSink(&ctrl_release);
}
using ClipboardHistoryPasteType =
ClipboardHistoryControllerImpl::ClipboardHistoryPasteType;
bool IsPlainTextPaste(ClipboardHistoryPasteType paste_type) {
switch (paste_type) {
case ClipboardHistoryPasteType::kPlainTextAccelerator:
case ClipboardHistoryPasteType::kPlainTextKeystroke:
case ClipboardHistoryPasteType::kPlainTextMouse:
case ClipboardHistoryPasteType::kPlainTextTouch:
case ClipboardHistoryPasteType::kPlainTextVirtualKeyboard:
case ClipboardHistoryPasteType::kPlainTextCtrlV:
return true;
case ClipboardHistoryPasteType::kRichTextAccelerator:
case ClipboardHistoryPasteType::kRichTextKeystroke:
case ClipboardHistoryPasteType::kRichTextMouse:
case ClipboardHistoryPasteType::kRichTextTouch:
case ClipboardHistoryPasteType::kRichTextVirtualKeyboard:
case ClipboardHistoryPasteType::kRichTextCtrlV:
return false;
}
}
ClipboardHistoryPasteType CalculatePasteType(
crosapi::mojom::ClipboardHistoryControllerShowSource paste_source,
int event_flags) {
// There are no specific flags that indicate a paste triggered by a
// keystroke, so assume by default that keystroke was the event source
// and then check for the other known possibilities. This assumption may
// cause pastes from unknown sources to be incorrectly captured as
// keystroke pastes, but we do not expect such cases to significantly
// alter metrics.
const bool paste_plain_text = event_flags & ui::EF_SHIFT_DOWN;
if (paste_source ==
crosapi::mojom::ClipboardHistoryControllerShowSource::kVirtualKeyboard) {
return paste_plain_text
? ClipboardHistoryPasteType::kPlainTextVirtualKeyboard
: ClipboardHistoryPasteType::kRichTextVirtualKeyboard;
}
ClipboardHistoryPasteType paste_type =
paste_plain_text ? ClipboardHistoryPasteType::kPlainTextKeystroke
: ClipboardHistoryPasteType::kRichTextKeystroke;
if (event_flags & ui::EF_MOUSE_BUTTON) {
paste_type = paste_plain_text ? ClipboardHistoryPasteType::kPlainTextMouse
: ClipboardHistoryPasteType::kRichTextMouse;
} else if (event_flags & ui::EF_FROM_TOUCH) {
paste_type = paste_plain_text ? ClipboardHistoryPasteType::kPlainTextTouch
: ClipboardHistoryPasteType::kRichTextTouch;
}
return paste_type;
}
} // namespace
// ClipboardHistoryControllerImpl::AcceleratorTarget ---------------------------
class ClipboardHistoryControllerImpl::AcceleratorTarget
: public ui::AcceleratorTarget {
public:
explicit AcceleratorTarget(ClipboardHistoryControllerImpl* controller)
: controller_(controller),
delete_selected_(ui::Accelerator(
/*key_code=*/ui::VKEY_BACK,
/*modifiers=*/ui::EF_NONE,
/*key_state=*/ui::Accelerator::KeyState::PRESSED)),
tab_navigation_(ui::Accelerator(
/*key_code=*/ui::VKEY_TAB,
/*modifiers=*/ui::EF_NONE,
/*key_state=*/ui::Accelerator::KeyState::PRESSED)),
shift_tab_navigation_(ui::Accelerator(
/*key_code=*/ui::VKEY_TAB,
/*modifiers=*/ui::EF_SHIFT_DOWN,
/*key_state=*/ui::Accelerator::KeyState::PRESSED)),
paste_first_item_(ui::Accelerator(
/*key_code=*/ui::VKEY_V,
/*modifiers=*/ui::EF_CONTROL_DOWN,
/*key_state=*/ui::Accelerator::KeyState::PRESSED)),
paste_first_item_plaintext_(ui::Accelerator(
/*key_code=*/ui::VKEY_V,
/*modifiers=*/ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN,
/*key_state=*/ui::Accelerator::KeyState::PRESSED)) {}
AcceleratorTarget(const AcceleratorTarget&) = delete;
AcceleratorTarget& operator=(const AcceleratorTarget&) = delete;
~AcceleratorTarget() override = default;
void OnMenuShown() {
Shell::Get()->accelerator_controller()->Register(
{delete_selected_, tab_navigation_, shift_tab_navigation_,
paste_first_item_, paste_first_item_plaintext_},
/*target=*/this);
}
void OnMenuClosed() {
Shell::Get()->accelerator_controller()->UnregisterAll(/*target=*/this);
}
private:
// ui::AcceleratorTarget:
bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
CHECK(controller_->IsMenuShowing());
if (accelerator == delete_selected_) {
HandleDeleteSelected();
} else if (accelerator == tab_navigation_) {
HandleTab();
} else if (accelerator == shift_tab_navigation_) {
HandleShiftTab();
} else if (accelerator == paste_first_item_) {
HandlePasteFirstItem(ClipboardHistoryPasteType::kRichTextCtrlV);
} else if (accelerator == paste_first_item_plaintext_) {
HandlePasteFirstItem(ClipboardHistoryPasteType::kPlainTextCtrlV);
} else {
NOTREACHED();
}
return true;
}
bool CanHandleAccelerators() const override {
return controller_->IsMenuShowing() ||
controller_->HasAvailableHistoryItems();
}
void HandleDeleteSelected() { controller_->DeleteSelectedMenuItemIfAny(); }
void HandleTab() { controller_->AdvancePseudoFocus(/*reverse=*/false); }
void HandleShiftTab() { controller_->AdvancePseudoFocus(/*reverse=*/true); }
void HandlePasteFirstItem(ClipboardHistoryPasteType paste_type) {
const auto first_item_command_id =
controller_->context_menu_->GetFirstMenuItemCommand();
CHECK(first_item_command_id);
controller_->PasteClipboardItemByCommandId(*first_item_command_id,
paste_type);
}
// The controller responsible for showing the clipboard history menu.
const raw_ptr<ClipboardHistoryControllerImpl> controller_;
// Deletes the selected menu item.
const ui::Accelerator delete_selected_;
// Moves the pseudo focus forward.
const ui::Accelerator tab_navigation_;
// Moves the pseudo focus backward.
const ui::Accelerator shift_tab_navigation_;
// Pastes the first item in the clipboard history menu.
const ui::Accelerator paste_first_item_;
// Pastes the plain text data of the first item in the clipboard history menu.
const ui::Accelerator paste_first_item_plaintext_;
};
// ClipboardHistoryControllerImpl::MenuDelegate --------------------------------
class ClipboardHistoryControllerImpl::MenuDelegate
: public ui::SimpleMenuModel::Delegate {
public:
explicit MenuDelegate(ClipboardHistoryControllerImpl* controller)
: controller_(controller) {}
MenuDelegate(const MenuDelegate&) = delete;
MenuDelegate& operator=(const MenuDelegate&) = delete;
// ui::SimpleMenuModel::Delegate:
void ExecuteCommand(int command_id, int event_flags) override {
controller_->ExecuteCommand(command_id, event_flags);
}
private:
// The controller responsible for showing the Clipboard History menu.
const raw_ptr<ClipboardHistoryControllerImpl> controller_;
};
// ClipboardHistoryControllerImpl ----------------------------------------------
ClipboardHistoryControllerImpl::ClipboardHistoryControllerImpl(
std::unique_ptr<ClipboardHistoryControllerDelegate> delegate)
: delegate_(std::move(delegate)),
image_model_factory_(delegate_->CreateImageModelFactory()),
url_title_fetcher_(delegate_->CreateUrlTitleFetcher()),
clipboard_history_(std::make_unique<ClipboardHistory>()),
resource_manager_(std::make_unique<ClipboardHistoryResourceManager>(
clipboard_history_.get())),
accelerator_target_(std::make_unique<AcceleratorTarget>(this)),
nudge_controller_(
std::make_unique<ClipboardNudgeController>(clipboard_history_.get())),
menu_delegate_(std::make_unique<MenuDelegate>(this)) {
if (!image_model_factory_ || !url_title_fetcher_) {
CHECK_IS_TEST();
}
clipboard_history_->AddObserver(this);
resource_manager_->AddObserver(this);
SessionController::Get()->AddObserver(this);
}
ClipboardHistoryControllerImpl::~ClipboardHistoryControllerImpl() {
SessionController::Get()->RemoveObserver(this);
resource_manager_->RemoveObserver(this);
clipboard_history_->RemoveObserver(this);
}
// static
void ClipboardHistoryControllerImpl::RegisterProfilePrefs(
PrefRegistrySimple* registry) {
ClipboardNudgeController::RegisterProfilePrefs(registry);
registry->RegisterTimePref(prefs::kMultipasteMenuLastTimeShown, base::Time());
}
void ClipboardHistoryControllerImpl::Shutdown() {
if (IsMenuShowing()) {
context_menu_->Cancel(/*will_paste_item=*/false);
}
nudge_controller_.reset();
}
bool ClipboardHistoryControllerImpl::IsMenuShowing() const {
return context_menu_ && context_menu_->IsRunning();
}
void ClipboardHistoryControllerImpl::ToggleMenuShownByAccelerator(
bool is_plain_text_paste) {
if (IsMenuShowing()) {
// Before hiding the menu, paste the selected menu item, or the first item
// if none is selected.
PasteClipboardItemByCommandId(
context_menu_->GetSelectedMenuItemCommand().value_or(
clipboard_history_util::kFirstItemCommandId),
is_plain_text_paste ? ClipboardHistoryPasteType::kPlainTextAccelerator
: ClipboardHistoryPasteType::kRichTextAccelerator);
return;
}
// Do not allow the plain text shortcut to open the menu.
if (is_plain_text_paste) {
return;
}
if (clipboard_history_util::IsEnabledInCurrentMode() && IsEmpty()) {
nudge_controller_->ShowNudge(ClipboardNudgeType::kZeroStateNudge);
return;
}
ShowMenu(CalculateAnchorRect(), ui::MENU_SOURCE_KEYBOARD,
crosapi::mojom::ClipboardHistoryControllerShowSource::kAccelerator);
}
void ClipboardHistoryControllerImpl::AddObserver(
ClipboardHistoryController::Observer* observer) {
observers_.AddObserver(observer);
}
void ClipboardHistoryControllerImpl::RemoveObserver(
ClipboardHistoryController::Observer* observer) {
observers_.RemoveObserver(observer);
}
bool ClipboardHistoryControllerImpl::ShowMenu(
const gfx::Rect& anchor_rect,
ui::MenuSourceType source_type,
crosapi::mojom::ClipboardHistoryControllerShowSource show_source) {
return ShowMenu(anchor_rect, source_type, show_source,
OnMenuClosingCallback());
}
bool ClipboardHistoryControllerImpl::ShowMenu(
const gfx::Rect& anchor_rect,
ui::MenuSourceType source_type,
crosapi::mojom::ClipboardHistoryControllerShowSource show_source,
OnMenuClosingCallback callback) {
if (IsMenuShowing() || !HasAvailableHistoryItems()) {
return false;
}
// Close the running context menu, if any, before showing the clipboard
// history menu.
if (auto* active_menu_instance = views::MenuController::GetActiveInstance()) {
active_menu_instance->Cancel(views::MenuController::ExitType::kAll);
}
last_menu_source_ = show_source;
// `Unretained()` is safe because `this` owns `context_menu_`.
context_menu_ = ClipboardHistoryMenuModelAdapter::Create(
menu_delegate_.get(), std::move(callback),
base::BindRepeating(&ClipboardHistoryControllerImpl::OnMenuClosed,
base::Unretained(this)),
clipboard_history_.get());
context_menu_->Run(anchor_rect, source_type, show_source,
GetMenuLastTimeShown(),
nudge_controller_->GetNudgeLastTimeShown());
CHECK(IsMenuShowing());
accelerator_target_->OnMenuShown();
// The first menu item should be selected by default after the clipboard
// history menu shows. Note that the menu item is selected asynchronously
// to avoid the interference from synthesized mouse events.
menu_task_timer_.Start(
FROM_HERE, base::TimeDelta(),
base::BindOnce(
[](const base::WeakPtr<ClipboardHistoryControllerImpl>&
controller_weak_ptr) {
if (!controller_weak_ptr) {
return;
}
controller_weak_ptr->context_menu_->SelectMenuItemWithCommandId(
clipboard_history_util::kFirstItemCommandId);
if (controller_weak_ptr->initial_item_selected_callback_for_test_) {
controller_weak_ptr->initial_item_selected_callback_for_test_
.Run();
}
},
weak_ptr_factory_.GetWeakPtr()));
MarkMenuLastTimeShown();
base::UmaHistogramEnumeration("Ash.ClipboardHistory.ContextMenu.ShowMenu",
show_source);
for (auto& observer : observers_) {
observer.OnClipboardHistoryMenuShown(show_source);
}
return true;
}
bool ClipboardHistoryControllerImpl::IsEmpty() const {
return clipboard_history_->IsEmpty();
}
void ClipboardHistoryControllerImpl::FireItemUpdateNotificationTimerForTest() {
item_update_notification_timer_.FireNow();
}
void ClipboardHistoryControllerImpl::GetHistoryValues(
GetHistoryValuesCallback callback) const {
// Map of `ClipboardHistoryItem` IDs to their corresponding bitmaps.
std::map<base::UnguessableToken, SkBitmap> bitmaps_to_be_encoded;
for (auto& item : clipboard_history_->GetItems()) {
if (item.display_format() ==
crosapi::mojom::ClipboardHistoryDisplayFormat::kPng) {
const auto& maybe_png = item.data().maybe_png();
if (!maybe_png.has_value()) {
// The clipboard contains an image which has not yet been encoded to a
// PNG.
auto maybe_bitmap = item.data().GetBitmapIfPngNotEncoded();
DCHECK(maybe_bitmap.has_value());
bitmaps_to_be_encoded.emplace(item.id(),
std::move(maybe_bitmap.value()));
}
}
}
// Map of `ClipboardHistoryItem` IDs to their encoded PNGs.
auto encoded_pngs = std::make_unique<
std::map<base::UnguessableToken, std::vector<uint8_t>>>();
auto* encoded_pngs_ptr = encoded_pngs.get();
// Post back to this sequence once all images have been encoded.
base::RepeatingClosure barrier = base::BarrierClosure(
bitmaps_to_be_encoded.size(),
base::BindPostTaskToCurrentDefault(base::BindOnce(
&ClipboardHistoryControllerImpl::GetHistoryValuesWithEncodedPNGs,
weak_ptr_factory_.GetMutableWeakPtr(), std::move(callback),
std::move(encoded_pngs))));
// Encode images on background threads.
for (auto id_and_bitmap : bitmaps_to_be_encoded) {
base::ThreadPool::PostTask(
FROM_HERE, base::BindOnce(&EncodeBitmapToPNG, barrier, encoded_pngs_ptr,
std::move(id_and_bitmap.first),
std::move(id_and_bitmap.second)));
}
if (!new_bitmap_to_write_while_encoding_for_test_.isNull()) {
ui::ScopedClipboardWriter scw(ui::ClipboardBuffer::kCopyPaste);
scw.WriteImage(new_bitmap_to_write_while_encoding_for_test_);
new_bitmap_to_write_while_encoding_for_test_.reset();
}
}
gfx::Rect ClipboardHistoryControllerImpl::GetMenuBoundsInScreenForTest() const {
return context_menu_->GetMenuBoundsInScreenForTest(); // IN-TEST
}
void ClipboardHistoryControllerImpl::BlockGetHistoryValuesForTest() {
get_history_values_blocker_for_test_.reset();
get_history_values_blocker_for_test_ = std::make_unique<base::OneShotEvent>();
}
void ClipboardHistoryControllerImpl::ResumeGetHistoryValuesForTest() {
DCHECK(get_history_values_blocker_for_test_);
get_history_values_blocker_for_test_->Signal();
}
void ClipboardHistoryControllerImpl::OnScreenshotNotificationCreated() {
nudge_controller_->MarkScreenshotNotificationShown();
}
bool ClipboardHistoryControllerImpl::HasAvailableHistoryItems() const {
return clipboard_history_util::IsEnabledInCurrentMode() && !IsEmpty();
}
std::unique_ptr<ScopedClipboardHistoryPause>
ClipboardHistoryControllerImpl::CreateScopedPause() {
return std::make_unique<ScopedClipboardHistoryPauseImpl>(
clipboard_history_.get());
}
void ClipboardHistoryControllerImpl::GetHistoryValuesWithEncodedPNGs(
GetHistoryValuesCallback callback,
std::unique_ptr<std::map<base::UnguessableToken, std::vector<uint8_t>>>
encoded_pngs) {
// If a test is performing some work that must be done before history values
// are returned, wait to run this function until that work is finished.
if (get_history_values_blocker_for_test_ &&
!get_history_values_blocker_for_test_->is_signaled()) {
get_history_values_blocker_for_test_->Post(
FROM_HERE,
base::BindOnce(
&ClipboardHistoryControllerImpl::GetHistoryValuesWithEncodedPNGs,
weak_ptr_factory_.GetWeakPtr(), std::move(callback),
std::move(encoded_pngs)));
return;
}
std::vector<ClipboardHistoryItem> item_results;
// Check after asynchronous PNG encoding finishes to make sure we have not
// entered a state where clipboard history is disabled, e.g., a locked screen.
if (!clipboard_history_util::IsEnabledInCurrentMode()) {
std::move(callback).Run(std::move(item_results));
return;
}
bool all_images_encoded = true;
for (auto& item : clipboard_history_->GetItems()) {
if (item.display_format() ==
crosapi::mojom::ClipboardHistoryDisplayFormat::kPng &&
!item.data().maybe_png().has_value()) {
// The clipboard contains an image which has not yet been encoded to a
// PNG. Hopefully we just finished encoding and the PNG can be found
// in `encoded_pngs`; otherwise this item was added while other PNGs
// were being encoded.
auto png_it = encoded_pngs->find(item.id());
if (png_it == encoded_pngs->end()) {
// Can't find the encoded PNG. We'll need to restart
// `GetHistoryValues()` from the top, but allow this for loop to finish
// to let PNGs we've already encoded get set to their appropriate
// clipboards, to avoid re-encoding.
all_images_encoded = false;
} else {
item.data().SetPngDataAfterEncoding(std::move(png_it->second));
}
}
item_results.emplace_back(item);
}
if (!all_images_encoded) {
GetHistoryValues(std::move(callback));
return;
}
std::move(callback).Run(std::move(item_results));
}
std::vector<std::string> ClipboardHistoryControllerImpl::GetHistoryItemIds()
const {
std::vector<std::string> item_ids;
if (HasAvailableHistoryItems()) {
for (const auto& item : history()->GetItems()) {
item_ids.push_back(item.id().ToString());
}
}
return item_ids;
}
bool ClipboardHistoryControllerImpl::PasteClipboardItemById(
const std::string& item_id,
int event_flags,
crosapi::mojom::ClipboardHistoryControllerShowSource paste_source) {
const std::list<ClipboardHistoryItem>& history_items = history()->GetItems();
auto iter_by_id = std::find_if(history_items.cbegin(), history_items.cend(),
[&item_id](const ClipboardHistoryItem& item) {
return item.id().ToString() == item_id;
});
if (iter_by_id == history_items.cend()) {
return false;
}
RecordPasteItemIndex(std::distance(history_items.cbegin(), iter_by_id) +
clipboard_history_util::kFirstItemCommandId);
MaybePostPasteTask(*iter_by_id, CalculatePasteType(paste_source, event_flags),
paste_source);
return true;
}
bool ClipboardHistoryControllerImpl::DeleteClipboardItemById(
const std::string& item_id) {
for (const auto& item : history()->GetItems()) {
if (item.id().ToString() == item_id) {
DeleteClipboardHistoryItem(item);
return true;
}
}
return false;
}
void ClipboardHistoryControllerImpl::OnClipboardHistoryItemAdded(
const ClipboardHistoryItem& item,
bool is_duplicate) {
PostItemUpdateNotificationTask();
}
void ClipboardHistoryControllerImpl::OnClipboardHistoryItemRemoved(
const ClipboardHistoryItem& item) {
PostItemUpdateNotificationTask();
}
void ClipboardHistoryControllerImpl::OnClipboardHistoryCleared() {
// Prevent clipboard contents from being restored if the clipboard history is
// cleared shortly after pasting an item.
weak_ptr_factory_.InvalidateWeakPtrs();
// Notify observers of the history being cleared after invalidating weak
// pointers.
PostItemUpdateNotificationTask();
// Make sure the menu is closed now that there are no items to show.
if (IsMenuShowing()) {
context_menu_->Cancel(/*will_paste_item=*/false);
}
}
void ClipboardHistoryControllerImpl::OnOperationConfirmed(bool copy) {
static int confirmed_paste_count = 0;
// Here we assume that a paste operation from the clipboard history menu never
// interleaves with a user-initiated copy or paste operation from another
// source, such as pressing the ctrl-v accelerator or clicking a context menu
// option. In other words, when `pastes_to_be_confirmed_` is positive, the
// next confirmed operation is expected to be a paste from clipboard history.
// This assumption should hold in most cases given that the clipboard history
// menu is always closed after one paste, and it usually takes a relatively
// long time for a user to perform the next copy or paste. For this metric, we
// tolerate a small margin of error.
if (pastes_to_be_confirmed_ > 0 && !copy) {
++confirmed_paste_count;
--pastes_to_be_confirmed_;
} else {
// Note that both copies and pastes from the standard clipboard cause the
// clipboard history consecutive paste count to be emitted and reset.
if (confirmed_paste_count > 0) {
base::UmaHistogramCounts100("Ash.ClipboardHistory.ConsecutivePastes",
confirmed_paste_count);
confirmed_paste_count = 0;
}
if (copy) {
// Record copy actions once they are confirmed, rather than when clipboard
// data first changes, to allow multiple data changes to be debounced into
// a single copy operation. This ensures that each user-initiated copy is
// recorded only once. See `ClipboardHistory::OnDataChanged()` for further
// explanation.
base::RecordAction(base::UserMetricsAction("Ash_Clipboard_CopiedItem"));
} else {
// Pastes from clipboard history are already recorded in
// `PasteMenuItemData()`. Here, we record just pastes from the standard
// clipboard, to see how standard clipboard pastes interleave with
// clipboard history pastes.
base::RecordAction(base::UserMetricsAction("Ash_Clipboard_PastedItem"));
}
// Verify that this operation did not interleave with a clipboard history
// paste.
DCHECK_EQ(pastes_to_be_confirmed_, 0);
// Whether or not the non-interleaving assumption has held, always reset
// `pastes_to_be_confirmed_` to prevent standard clipboard pastes from
// possibly being counted as clipboard history pastes, which could
// significantly affect the clipboard history consecutive pastes metric.
pastes_to_be_confirmed_ = 0;
}
// Callback will be run after clipboard data restoration.
if (confirmed_operation_callback_for_test_ && !clipboard_data_replaced_) {
confirmed_operation_callback_for_test_.Run(/*success=*/true);
}
}
void ClipboardHistoryControllerImpl::OnCachedImageModelUpdated(
const std::vector<base::UnguessableToken>& menu_item_ids) {
PostItemUpdateNotificationTask();
}
void ClipboardHistoryControllerImpl::OnSessionStateChanged(
session_manager::SessionState state) {
PostItemUpdateNotificationTask();
}
void ClipboardHistoryControllerImpl::OnLoginStatusChanged(
LoginStatus login_status) {
PostItemUpdateNotificationTask();
}
void ClipboardHistoryControllerImpl::PostItemUpdateNotificationTask() {
// Uses the async task to debounce multiple clipboard history changes in
// short duration. Restart the timer if it is running.
// This is done to avoid notifying observers multiple times if there are
// multiple clipboard history changes in a short period. For example, if the
// clipboard history reaches the cache limit and a new clipboard history item
// arrives at the same time, there would be two clipboard history changes: the
// addition of the new item and the removal of an obsolete item. In this case,
// this class should only notify observers only once.
item_update_notification_timer_.Start(
FROM_HERE, base::TimeDelta(),
base::BindOnce(
&ClipboardHistoryControllerImpl::MaybeNotifyObserversOfItemUpdate,
weak_ptr_factory_.GetWeakPtr()));
}
void ClipboardHistoryControllerImpl::MaybeNotifyObserversOfItemUpdate() {
const bool has_available_items = HasAvailableHistoryItems();
if (!has_available_items && !has_available_items_in_last_update_) {
// There are no available items, and there were none in the last
// notification either. Nothing has changed, so return early.
return;
}
for (auto& observer : observers_) {
observer.OnClipboardHistoryItemsUpdated();
}
has_available_items_in_last_update_ = has_available_items;
}
void ClipboardHistoryControllerImpl::ExecuteCommand(int command_id,
int event_flags) {
DCHECK(context_menu_);
DCHECK_GE(command_id, clipboard_history_util::kFirstItemCommandId);
DCHECK_LE(command_id, clipboard_history_util::kMaxItemCommandId);
using Action = clipboard_history_util::Action;
Action action = context_menu_->GetActionForCommandId(command_id);
switch (action) {
case Action::kPaste:
PasteClipboardItemByCommandId(
command_id, CalculatePasteType(last_menu_source_, event_flags));
return;
case Action::kDelete:
DeleteItemWithCommandId(command_id);
return;
case Action::kSelect:
context_menu_->SelectMenuItemWithCommandId(command_id);
return;
case Action::kSelectItemHoveredByMouse:
context_menu_->SelectMenuItemHoveredByMouse();
return;
case Action::kEmpty:
DUMP_WILL_BE_NOTREACHED();
return;
}
}
void ClipboardHistoryControllerImpl::PasteClipboardItemByCommandId(
int command_id,
ClipboardHistoryPasteType paste_type) {
// Force close the context menu. Failure to do so before dispatching our
// synthetic key event will result in the context menu consuming the event.
// When closing the menu, indicate that the menu is closing because of an
// imminent paste. Note that in some cases, this will indicate paste intent
// for pastes that ultimately fail. For now, this is an acceptable inaccuracy.
CHECK(context_menu_);
context_menu_->Cancel(/*will_paste_item=*/true);
// `command_id` should match the pasted item's index in `context_menu_`.
RecordPasteItemIndex(command_id);
MaybePostPasteTask(context_menu_->GetItemFromCommandId(command_id),
paste_type, last_menu_source_);
}
void ClipboardHistoryControllerImpl::MaybePostPasteTask(
const ClipboardHistoryItem& item,
ClipboardHistoryPasteType paste_type,
crosapi::mojom::ClipboardHistoryControllerShowSource paste_source) {
// Deactivate ClipboardImageModelFactory prior to pasting to ensure that any
// modifications to the clipboard for HTML rendering purposes are reversed.
// This factory may be nullptr in tests.
if (auto* clipboard_image_factory = ClipboardImageModelFactory::Get()) {
clipboard_image_factory->Deactivate();
}
if (auto* active_window = window_util::GetActiveWindow()) {
// Paste asynchronously to ensure ARC windows handle paste events correctly.
base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE,
base::BindOnce(
&ClipboardHistoryControllerImpl::PasteClipboardHistoryItem,
weak_ptr_factory_.GetWeakPtr(), active_window, item, paste_type,
paste_source));
}
}
void ClipboardHistoryControllerImpl::PasteClipboardHistoryItem(
aura::Window* intended_window,
ClipboardHistoryItem item,
ClipboardHistoryPasteType paste_type,
crosapi::mojom::ClipboardHistoryControllerShowSource paste_source) {
// Return early if any of these conditions occur:
// 1. The original clipboard data has been replaced by an in-progress
// clipboard history paste.
// 2. The active window has changed.
// 3. The clipboard history feature is disabled under the current mode.
if (clipboard_data_replaced_ || !intended_window ||
intended_window != window_util::GetActiveWindow() ||
!clipboard_history_util::IsEnabledInCurrentMode()) {
if (confirmed_operation_callback_for_test_)
confirmed_operation_callback_for_test_.Run(/*success=*/false);
return;
}
// Get information about the data to be pasted.
bool paste_plain_text = IsPlainTextPaste(paste_type);
auto* clipboard = GetClipboard();
ui::DataTransferEndpoint data_dst(ui::EndpointType::kClipboardHistory);
const auto* current_clipboard_data = clipboard->GetClipboardData(&data_dst);
// Clipboard history pastes are performed by temporarily writing data to the
// system clipboard, if necessary, and then issuing a standard paste.
// Determine the data we should temporarily write to the clipboard, if any, so
// that we can paste the selected history item.
std::unique_ptr<ui::ClipboardData> data_to_paste;
if (paste_plain_text) {
data_to_paste = std::make_unique<ui::ClipboardData>();
data_to_paste->set_commit_time(item.data().commit_time());
data_to_paste->set_text(item.data().text());
auto data_src = item.data().source();
if (data_src) {
data_to_paste->set_source(data_src);
}
} else if (!current_clipboard_data ||
*current_clipboard_data != item.data()) {
data_to_paste = std::make_unique<ui::ClipboardData>(item.data());
}
// Pause changes to clipboard history while manipulating the clipboard.
std::unique_ptr<ui::ClipboardData> replaced_data;
// If necessary, replace the clipboard's current data before issuing a paste.
if (data_to_paste) {
ScopedClipboardHistoryPauseImpl scoped_pause(
clipboard_history_.get(),
clipboard_history_util::PauseBehavior::kDefault);
replaced_data =
GetClipboard()->WriteClipboardData(std::move(data_to_paste));
clipboard_data_replaced_ = !!replaced_data;
}
++pastes_to_be_confirmed_;
// Use synthetic pastes as a fallback solution.
if (!delegate_->Paste()) {
SyntheticPaste(paste_source);
}
clipboard_history_util::RecordClipboardHistoryItemPasted(item);
base::UmaHistogramEnumeration("Ash.ClipboardHistory.PasteType", paste_type);
base::UmaHistogramEnumeration("Ash.ClipboardHistory.PasteSource",
paste_source);
for (auto& observer : observers_) {
observer.OnClipboardHistoryPasted();
}
// If the clipboard was not changed--i.e., we pasted the full data on the
// clipboard--then we are done modifying the clipboard buffer.
if (!replaced_data) {
return;
}
// Restore the clipboard data asynchronously. Some apps take a long time to
// receive the paste event, and some apps will read from the clipboard
// multiple times per paste. Wait a bit before writing `data_to_restore` back
// to the clipboard.
base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
FROM_HERE,
base::BindOnce(
[](const base::WeakPtr<ClipboardHistoryControllerImpl>& weak_ptr,
std::unique_ptr<ui::ClipboardData> data_to_restore) {
std::unique_ptr<ScopedClipboardHistoryPauseImpl> scoped_pause;
if (weak_ptr) {
// When restoring the original clipboard content, pause clipboard
// history to avoid committing data already at the top of the
// clipboard history list.
scoped_pause = std::make_unique<ScopedClipboardHistoryPauseImpl>(
weak_ptr->clipboard_history_.get(),
clipboard_history_util::PauseBehavior::kDefault);
}
GetClipboard()->WriteClipboardData(std::move(data_to_restore));
if (weak_ptr) {
weak_ptr->clipboard_data_replaced_ = false;
// Confirm the operation after data restoration if needed.
if (auto& callback_for_test =
weak_ptr->confirmed_operation_callback_for_test_;
callback_for_test && !weak_ptr->pastes_to_be_confirmed_) {
callback_for_test.Run(/*success=*/true);
}
}
},
weak_ptr_factory_.GetWeakPtr(), std::move(replaced_data)),
buffer_restoration_delay_for_test_.value_or(base::Milliseconds(200)));
}
void ClipboardHistoryControllerImpl::DeleteSelectedMenuItemIfAny() {
DCHECK(context_menu_);
auto selected_command = context_menu_->GetSelectedMenuItemCommand();
// Return early if no item is selected.
if (!selected_command.has_value())
return;
DeleteItemWithCommandId(*selected_command);
}
void ClipboardHistoryControllerImpl::DeleteItemWithCommandId(int command_id) {
DCHECK(context_menu_);
// Pressing VKEY_DELETE is handled here via AcceleratorTarget because the
// contextual menu consumes the key event. Record the "pressing the delete
// button" histogram here because this action does the same thing as
// activating the button directly via click/tap. There is no special handling
// for pasting an item via VKEY_RETURN because in that case the menu does not
// process the key event.
const auto& to_be_deleted_item =
context_menu_->GetItemFromCommandId(command_id);
DeleteClipboardHistoryItem(to_be_deleted_item);
// If the item to be deleted is the last one, close the whole menu.
if (context_menu_->GetMenuItemsCount() == 1) {
context_menu_->Cancel(/*will_paste_item=*/false);
return;
}
context_menu_->RemoveMenuItemWithCommandId(command_id);
}
void ClipboardHistoryControllerImpl::DeleteClipboardHistoryItem(
const ClipboardHistoryItem& item) {
clipboard_history_util::RecordClipboardHistoryItemDeleted(item);
clipboard_history_->RemoveItemForId(item.id());
}
void ClipboardHistoryControllerImpl::AdvancePseudoFocus(bool reverse) {
DCHECK(context_menu_);
context_menu_->AdvancePseudoFocus(reverse);
}
gfx::Rect ClipboardHistoryControllerImpl::CalculateAnchorRect() const {
display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
auto* host = GetWindowTreeHostForDisplay(display.id());
// Some web apps render the caret in an IFrame, and we will not get the
// bounds in that case.
// TODO(crbug.com/40137728): Show the menu in the middle of the
// webview if the bounds are empty.
ui::TextInputClient* text_input_client =
host->GetInputMethod()->GetTextInputClient();
// `text_input_client` may be null. For example, in clamshell mode and without
// any window open.
const gfx::Rect textfield_bounds =
text_input_client ? text_input_client->GetCaretBounds() : gfx::Rect();
// Note that the width of caret's bounds may be zero in some views (such as
// the search bar of Google search web page). So we cannot use
// gfx::Size::IsEmpty() here. In addition, the applications using IFrame may
// provide unreliable `textfield_bounds` which are not fully contained by the
// display bounds.
const bool textfield_bounds_are_valid =
textfield_bounds.size() != gfx::Size() &&
IsRectContainedByAnyDisplay(textfield_bounds);
if (textfield_bounds_are_valid)
return textfield_bounds;
return gfx::Rect(display::Screen::GetScreen()->GetCursorScreenPoint(),
gfx::Size());
}
void ClipboardHistoryControllerImpl::OnMenuClosed() {
accelerator_target_->OnMenuClosed();
// Reset `context_menu_` in the asynchronous way. Because the menu may be
// accessed after `OnMenuClosed()` is called.
menu_task_timer_.Start(
FROM_HERE, base::TimeDelta(),
base::BindOnce(
[](const base::WeakPtr<ClipboardHistoryControllerImpl>&
controller_weak_ptr) {
if (controller_weak_ptr)
controller_weak_ptr->context_menu_.reset();
},
weak_ptr_factory_.GetWeakPtr()));
}
} // namespace ash
Codebase Browser
chromium