| // Copyright 2018 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 <msctf.h> | |
| #include <map> | |
| #include "base/logging.h" | |
| #include "base/memory/ref_counted.h" | |
| #include "base/message_loop/message_loop.h" | |
| #include "base/no_destructor.h" | |
| #include "base/threading/thread_local_storage.h" | |
| #include "base/win/scoped_variant.h" | |
| #include "ui/base/ime/text_input_client.h" | |
| #include "ui/base/ime/win/tsf_bridge.h" | |
| #include "ui/base/ime/win/tsf_text_store.h" | |
| #include "ui/base/ui_base_features.h" | |
| namespace ui { | |
| namespace { | |
| // TSFBridgeImpl ----------------------------------------------------------- | |
| // A TLS implementation of TSFBridge. | |
| class TSFBridgeImpl : public TSFBridge { | |
| public: | |
| TSFBridgeImpl(); | |
| ~TSFBridgeImpl() override; | |
| bool Initialize(); | |
| // TsfBridge: | |
| void OnTextInputTypeChanged(const TextInputClient* client) override; | |
| void OnTextLayoutChanged() override; | |
| bool CancelComposition() override; | |
| bool ConfirmComposition() override; | |
| void SetFocusedClient(HWND focused_window, TextInputClient* client) override; | |
| void RemoveFocusedClient(TextInputClient* client) override; | |
| Microsoft::WRL::ComPtr<ITfThreadMgr> GetThreadManager() override; | |
| TextInputClient* GetFocusedTextInputClient() const override; | |
| private: | |
| // Returns true if |tsf_document_map_| is successfully initialized. This | |
| // method should be called from and only from Initialize(). | |
| bool InitializeDocumentMapInternal(); | |
| // Returns true if |context| is successfully updated to be a disabled | |
| // context, where an IME should be deactivated. This is suitable for some | |
| // special input context such as password fields. | |
| bool InitializeDisabledContext(ITfContext* context); | |
| // Returns true if a TSF document manager and a TSF context is successfully | |
| // created with associating with given |text_store|. The returned | |
| // |source_cookie| indicates the binding between |text_store| and |context|. | |
| // You can pass nullptr to |text_store| and |source_cookie| when text store is | |
| // not necessary. | |
| bool CreateDocumentManager(TSFTextStore* text_store, | |
| ITfDocumentMgr** document_manager, | |
| ITfContext** context, | |
| DWORD* source_cookie); | |
| // Returns true if |document_manager| is the focused document manager. | |
| bool IsFocused(ITfDocumentMgr* document_manager); | |
| // Returns true if already initialized. | |
| bool IsInitialized(); | |
| // Updates or clears the association maintained in the TSF runtime between | |
| // |attached_window_handle_| and the current document manager. Keeping this | |
| // association updated solves some tricky event ordering issues between | |
| // logical text input focus managed by Chrome and native text input focus | |
| // managed by the OS. | |
| // Background: | |
| // TSF runtime monitors some Win32 messages such as WM_ACTIVATE to | |
| // change the focused document manager. This is problematic when | |
| // TSFBridge::SetFocusedClient is called first then the target window | |
| // receives WM_ACTIVATE. This actually occurs in Aura environment where | |
| // WM_NCACTIVATE is used as a trigger to restore text input focus. | |
| // Caveats: | |
| // TSF runtime does not increment the reference count of the attached | |
| // document manager. See the comment inside the method body for | |
| // details. | |
| void UpdateAssociateFocus(); | |
| void ClearAssociateFocus(); | |
| // A triple of document manager, text store and binding cookie between | |
| // a context owned by the document manager and the text store. This is a | |
| // minimum working set of an editable document in TSF. | |
| struct TSFDocument { | |
| public: | |
| TSFDocument() : cookie(TF_INVALID_COOKIE) {} | |
| TSFDocument(const TSFDocument& src) | |
| : document_manager(src.document_manager), cookie(src.cookie) {} | |
| Microsoft::WRL::ComPtr<ITfDocumentMgr> document_manager; | |
| scoped_refptr<TSFTextStore> text_store; | |
| DWORD cookie; | |
| }; | |
| // Returns a pointer to TSFDocument that is associated with the current | |
| // TextInputType of |client_|. | |
| TSFDocument* GetAssociatedDocument(); | |
| // An ITfThreadMgr object to be used in focus and document management. | |
| Microsoft::WRL::ComPtr<ITfThreadMgr> thread_manager_; | |
| // A map from TextInputType to an editable document for TSF. We use multiple | |
| // TSF documents that have different InputScopes and TSF attributes based on | |
| // the TextInputType associated with the target document. For a TextInputType | |
| // that is not coverted by this map, a default document, e.g. the document | |
| // for TEXT_INPUT_TYPE_TEXT, should be used. | |
| // Note that some IMEs don't change their state unless the document focus is | |
| // changed. This is why we use multiple documents instead of changing TSF | |
| // metadata of a single document on the fly. | |
| typedef std::map<TextInputType, TSFDocument> TSFDocumentMap; | |
| TSFDocumentMap tsf_document_map_; | |
| // An identifier of TSF client. | |
| TfClientId client_id_ = TF_CLIENTID_NULL; | |
| // Current focused text input client. Do not free |client_|. | |
| TextInputClient* client_ = nullptr; | |
| // Represents the window that is currently owns text input focus. | |
| HWND attached_window_handle_ = nullptr; | |
| DISALLOW_COPY_AND_ASSIGN(TSFBridgeImpl); | |
| }; | |
| TSFBridgeImpl::TSFBridgeImpl() = default; | |
| TSFBridgeImpl::~TSFBridgeImpl() { | |
| DCHECK(base::MessageLoopForUI::IsCurrent()); | |
| if (!IsInitialized()) | |
| return; | |
| for (TSFDocumentMap::iterator it = tsf_document_map_.begin(); | |
| it != tsf_document_map_.end(); ++it) { | |
| Microsoft::WRL::ComPtr<ITfContext> context; | |
| Microsoft::WRL::ComPtr<ITfSource> source; | |
| if (it->second.cookie != TF_INVALID_COOKIE && | |
| SUCCEEDED( | |
| it->second.document_manager->GetBase(context.GetAddressOf())) && | |
| SUCCEEDED(context.CopyTo(source.GetAddressOf()))) { | |
| source->UnadviseSink(it->second.cookie); | |
| } | |
| } | |
| tsf_document_map_.clear(); | |
| client_id_ = TF_CLIENTID_NULL; | |
| } | |
| bool TSFBridgeImpl::Initialize() { | |
| DCHECK(base::MessageLoopForUI::IsCurrent()); | |
| if (client_id_ != TF_CLIENTID_NULL) { | |
| DVLOG(1) << "Already initialized."; | |
| return false; | |
| } | |
| if (FAILED(::CoCreateInstance(CLSID_TF_ThreadMgr, nullptr, CLSCTX_ALL, | |
| IID_PPV_ARGS(&thread_manager_)))) { | |
| DVLOG(1) << "Failed to create ThreadManager instance."; | |
| return false; | |
| } | |
| if (FAILED(thread_manager_->Activate(&client_id_))) { | |
| DVLOG(1) << "Failed to activate Thread Manager."; | |
| return false; | |
| } | |
| if (!InitializeDocumentMapInternal()) | |
| return false; | |
| // Japanese IME expects the default value of this compartment is | |
| // TF_SENTENCEMODE_PHRASEPREDICT like IMM32 implementation. This value is | |
| // managed per thread, so that it is enough to set this value at once. This | |
| // value does not affect other language's IME behaviors. | |
| Microsoft::WRL::ComPtr<ITfCompartmentMgr> thread_compartment_manager; | |
| if (FAILED( | |
| thread_manager_.CopyTo(thread_compartment_manager.GetAddressOf()))) { | |
| DVLOG(1) << "Failed to get ITfCompartmentMgr."; | |
| return false; | |
| } | |
| Microsoft::WRL::ComPtr<ITfCompartment> sentence_compartment; | |
| if (FAILED(thread_compartment_manager->GetCompartment( | |
| GUID_COMPARTMENT_KEYBOARD_INPUTMODE_SENTENCE, | |
| sentence_compartment.GetAddressOf()))) { | |
| DVLOG(1) << "Failed to get sentence compartment."; | |
| return false; | |
| } | |
| base::win::ScopedVariant sentence_variant; | |
| sentence_variant.Set(TF_SENTENCEMODE_PHRASEPREDICT); | |
| if (FAILED( | |
| sentence_compartment->SetValue(client_id_, sentence_variant.ptr()))) { | |
| DVLOG(1) << "Failed to change the sentence mode."; | |
| return false; | |
| } | |
| return true; | |
| } | |
| void TSFBridgeImpl::OnTextInputTypeChanged(const TextInputClient* client) { | |
| DCHECK(base::MessageLoopForUI::IsCurrent()); | |
| DCHECK(IsInitialized()); | |
| if (client != client_) { | |
| // Called from not focusing client. Do nothing. | |
| return; | |
| } | |
| UpdateAssociateFocus(); | |
| TSFDocument* document = GetAssociatedDocument(); | |
| if (!document) | |
| return; | |
| thread_manager_->SetFocus(document->document_manager.Get()); | |
| OnTextLayoutChanged(); | |
| } | |
| void TSFBridgeImpl::OnTextLayoutChanged() { | |
| TSFDocument* document = GetAssociatedDocument(); | |
| if (!document) | |
| return; | |
| if (!document->text_store) | |
| return; | |
| document->text_store->SendOnLayoutChange(); | |
| } | |
| bool TSFBridgeImpl::CancelComposition() { | |
| DCHECK(base::MessageLoopForUI::IsCurrent()); | |
| DCHECK(IsInitialized()); | |
| TSFDocument* document = GetAssociatedDocument(); | |
| if (!document) | |
| return false; | |
| if (!document->text_store) | |
| return false; | |
| return document->text_store->CancelComposition(); | |
| } | |
| bool TSFBridgeImpl::ConfirmComposition() { | |
| DCHECK(base::MessageLoopForUI::IsCurrent()); | |
| DCHECK(IsInitialized()); | |
| TSFDocument* document = GetAssociatedDocument(); | |
| if (!document) | |
| return false; | |
| if (!document->text_store) | |
| return false; | |
| return document->text_store->ConfirmComposition(); | |
| } | |
| void TSFBridgeImpl::SetFocusedClient(HWND focused_window, | |
| TextInputClient* client) { | |
| DCHECK(base::MessageLoopForUI::IsCurrent()); | |
| DCHECK(client); | |
| DCHECK(IsInitialized()); | |
| if (attached_window_handle_ != focused_window) | |
| ClearAssociateFocus(); | |
| client_ = client; | |
| attached_window_handle_ = focused_window; | |
| for (TSFDocumentMap::iterator it = tsf_document_map_.begin(); | |
| it != tsf_document_map_.end(); ++it) { | |
| if (it->second.text_store.get() == nullptr) | |
| continue; | |
| it->second.text_store->SetFocusedTextInputClient(focused_window, client); | |
| } | |
| // Synchronize text input type state. | |
| OnTextInputTypeChanged(client); | |
| } | |
| void TSFBridgeImpl::RemoveFocusedClient(TextInputClient* client) { | |
| DCHECK(base::MessageLoopForUI::IsCurrent()); | |
| DCHECK(IsInitialized()); | |
| if (client_ != client) | |
| return; | |
| ClearAssociateFocus(); | |
| client_ = nullptr; | |
| attached_window_handle_ = nullptr; | |
| for (TSFDocumentMap::iterator it = tsf_document_map_.begin(); | |
| it != tsf_document_map_.end(); ++it) { | |
| if (it->second.text_store.get() == nullptr) | |
| continue; | |
| it->second.text_store->SetFocusedTextInputClient(nullptr, nullptr); | |
| } | |
| } | |
| TextInputClient* TSFBridgeImpl::GetFocusedTextInputClient() const { | |
| return client_; | |
| } | |
| Microsoft::WRL::ComPtr<ITfThreadMgr> TSFBridgeImpl::GetThreadManager() { | |
| DCHECK(base::MessageLoopForUI::IsCurrent()); | |
| DCHECK(IsInitialized()); | |
| return thread_manager_; | |
| } | |
| bool TSFBridgeImpl::CreateDocumentManager(TSFTextStore* text_store, | |
| ITfDocumentMgr** document_manager, | |
| ITfContext** context, | |
| DWORD* source_cookie) { | |
| if (FAILED(thread_manager_->CreateDocumentMgr(document_manager))) { | |
| DVLOG(1) << "Failed to create Document Manager."; | |
| return false; | |
| } | |
| DWORD edit_cookie = TF_INVALID_EDIT_COOKIE; | |
| if (FAILED((*document_manager) | |
| ->CreateContext(client_id_, 0, | |
| static_cast<ITextStoreACP*>(text_store), | |
| context, &edit_cookie))) { | |
| DVLOG(1) << "Failed to create Context."; | |
| return false; | |
| } | |
| if (FAILED((*document_manager)->Push(*context))) { | |
| DVLOG(1) << "Failed to push context."; | |
| return false; | |
| } | |
| if (!text_store || !source_cookie) | |
| return true; | |
| Microsoft::WRL::ComPtr<ITfSource> source; | |
| if (FAILED((*context)->QueryInterface(IID_PPV_ARGS(&source)))) { | |
| DVLOG(1) << "Failed to get source."; | |
| return false; | |
| } | |
| if (FAILED(source->AdviseSink(IID_ITfTextEditSink, | |
| static_cast<ITfTextEditSink*>(text_store), | |
| source_cookie))) { | |
| DVLOG(1) << "AdviseSink failed."; | |
| return false; | |
| } | |
| if (*source_cookie == TF_INVALID_COOKIE) { | |
| DVLOG(1) << "The result of cookie is invalid."; | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool TSFBridgeImpl::InitializeDocumentMapInternal() { | |
| const TextInputType kTextInputTypes[] = { | |
| TEXT_INPUT_TYPE_NONE, TEXT_INPUT_TYPE_TEXT, | |
| TEXT_INPUT_TYPE_PASSWORD, TEXT_INPUT_TYPE_SEARCH, | |
| TEXT_INPUT_TYPE_EMAIL, TEXT_INPUT_TYPE_NUMBER, | |
| TEXT_INPUT_TYPE_TELEPHONE, TEXT_INPUT_TYPE_URL, | |
| }; | |
| for (size_t i = 0; i < arraysize(kTextInputTypes); ++i) { | |
| const TextInputType input_type = kTextInputTypes[i]; | |
| Microsoft::WRL::ComPtr<ITfContext> context; | |
| Microsoft::WRL::ComPtr<ITfDocumentMgr> document_manager; | |
| DWORD cookie = TF_INVALID_COOKIE; | |
| const bool use_null_text_store = (input_type == TEXT_INPUT_TYPE_NONE); | |
| DWORD* cookie_ptr = use_null_text_store ? nullptr : &cookie; | |
| scoped_refptr<TSFTextStore> text_store = | |
| use_null_text_store ? nullptr : new TSFTextStore(); | |
| if (!CreateDocumentManager(text_store.get(), | |
| document_manager.GetAddressOf(), | |
| context.GetAddressOf(), cookie_ptr)) | |
| return false; | |
| const bool use_disabled_context = (input_type == TEXT_INPUT_TYPE_PASSWORD || | |
| input_type == TEXT_INPUT_TYPE_NONE); | |
| if (use_disabled_context && !InitializeDisabledContext(context.Get())) | |
| return false; | |
| tsf_document_map_[input_type].text_store = text_store; | |
| tsf_document_map_[input_type].document_manager = document_manager; | |
| tsf_document_map_[input_type].cookie = cookie; | |
| } | |
| return true; | |
| } | |
| bool TSFBridgeImpl::InitializeDisabledContext(ITfContext* context) { | |
| Microsoft::WRL::ComPtr<ITfCompartmentMgr> compartment_mgr; | |
| if (FAILED(context->QueryInterface(IID_PPV_ARGS(&compartment_mgr)))) { | |
| DVLOG(1) << "Failed to get CompartmentMgr."; | |
| return false; | |
| } | |
| Microsoft::WRL::ComPtr<ITfCompartment> disabled_compartment; | |
| if (FAILED(compartment_mgr->GetCompartment( | |
| GUID_COMPARTMENT_KEYBOARD_DISABLED, | |
| disabled_compartment.GetAddressOf()))) { | |
| DVLOG(1) << "Failed to get keyboard disabled compartment."; | |
| return false; | |
| } | |
| base::win::ScopedVariant variant; | |
| variant.Set(1); | |
| if (FAILED(disabled_compartment->SetValue(client_id_, variant.ptr()))) { | |
| DVLOG(1) << "Failed to disable the DocumentMgr."; | |
| return false; | |
| } | |
| Microsoft::WRL::ComPtr<ITfCompartment> empty_context; | |
| if (FAILED(compartment_mgr->GetCompartment(GUID_COMPARTMENT_EMPTYCONTEXT, | |
| empty_context.GetAddressOf()))) { | |
| DVLOG(1) << "Failed to get empty context compartment."; | |
| return false; | |
| } | |
| base::win::ScopedVariant empty_context_variant; | |
| empty_context_variant.Set(static_cast<int32_t>(1)); | |
| if (FAILED( | |
| empty_context->SetValue(client_id_, empty_context_variant.ptr()))) { | |
| DVLOG(1) << "Failed to set empty context."; | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool TSFBridgeImpl::IsFocused(ITfDocumentMgr* document_manager) { | |
| Microsoft::WRL::ComPtr<ITfDocumentMgr> focused_document_manager; | |
| if (FAILED( | |
| thread_manager_->GetFocus(focused_document_manager.GetAddressOf()))) | |
| return false; | |
| return focused_document_manager.Get() == document_manager; | |
| } | |
| bool TSFBridgeImpl::IsInitialized() { | |
| return client_id_ != TF_CLIENTID_NULL; | |
| } | |
| void TSFBridgeImpl::UpdateAssociateFocus() { | |
| if (attached_window_handle_ == nullptr) | |
| return; | |
| TSFDocument* document = GetAssociatedDocument(); | |
| if (document == nullptr) { | |
| ClearAssociateFocus(); | |
| return; | |
| } | |
| // NOTE: ITfThreadMgr::AssociateFocus does not increment the ref count of | |
| // the document manager to be attached. It is our responsibility to make sure | |
| // the attached document manager will not be destroyed while it is attached. | |
| // This should be true as long as TSFBridge::Shutdown() is called late phase | |
| // of UI thread shutdown. | |
| Microsoft::WRL::ComPtr<ITfDocumentMgr> previous_focus; | |
| thread_manager_->AssociateFocus(attached_window_handle_, | |
| document->document_manager.Get(), | |
| previous_focus.GetAddressOf()); | |
| } | |
| void TSFBridgeImpl::ClearAssociateFocus() { | |
| if (attached_window_handle_ == nullptr) | |
| return; | |
| Microsoft::WRL::ComPtr<ITfDocumentMgr> previous_focus; | |
| thread_manager_->AssociateFocus(attached_window_handle_, nullptr, | |
| previous_focus.GetAddressOf()); | |
| } | |
| TSFBridgeImpl::TSFDocument* TSFBridgeImpl::GetAssociatedDocument() { | |
| if (!client_) | |
| return nullptr; | |
| TSFDocumentMap::iterator it = | |
| tsf_document_map_.find(client_->GetTextInputType()); | |
| if (it == tsf_document_map_.end()) { | |
| it = tsf_document_map_.find(TEXT_INPUT_TYPE_TEXT); | |
| // This check is necessary because it's possible that we failed to | |
| // initialize |tsf_document_map_| and it has no TEXT_INPUT_TYPE_TEXT. | |
| if (it == tsf_document_map_.end()) | |
| return nullptr; | |
| } | |
| return &it->second; | |
| } | |
| void Finalize(void* data) { | |
| TSFBridgeImpl* delegate = static_cast<TSFBridgeImpl*>(data); | |
| delete delegate; | |
| } | |
| base::ThreadLocalStorage::Slot& TSFBridgeTLS() { | |
| static base::NoDestructor<base::ThreadLocalStorage::Slot> tsf_bridge_tls( | |
| &Finalize); | |
| return *tsf_bridge_tls; | |
| } | |
| } // namespace | |
| // TsfBridge ----------------------------------------------------------------- | |
| TSFBridge::TSFBridge() {} | |
| TSFBridge::~TSFBridge() {} | |
| // static | |
| void TSFBridge::Initialize() { | |
| if (!base::MessageLoopForUI::IsCurrent()) { | |
| DVLOG(1) << "Do not use TSFBridge without UI thread."; | |
| return; | |
| } | |
| TSFBridgeImpl* delegate = static_cast<TSFBridgeImpl*>(TSFBridgeTLS().Get()); | |
| if (delegate) | |
| return; | |
| // If we aren't supporting TSF early out. | |
| if (!base::FeatureList::IsEnabled(features::kTSFImeSupport)) | |
| return; | |
| delegate = new TSFBridgeImpl(); | |
| TSFBridgeTLS().Set(delegate); | |
| delegate->Initialize(); | |
| } | |
| // static | |
| TSFBridge* TSFBridge::ReplaceForTesting(TSFBridge* bridge) { | |
| if (!base::MessageLoopForUI::IsCurrent()) { | |
| DVLOG(1) << "Do not use TSFBridge without UI thread."; | |
| return nullptr; | |
| } | |
| TSFBridge* old_bridge = TSFBridge::GetInstance(); | |
| TSFBridgeTLS().Set(bridge); | |
| return old_bridge; | |
| } | |
| // static | |
| void TSFBridge::Shutdown() { | |
| if (!base::MessageLoopForUI::IsCurrent()) { | |
| DVLOG(1) << "Do not use TSFBridge without UI thread."; | |
| } | |
| TSFBridgeImpl* delegate = static_cast<TSFBridgeImpl*>(TSFBridgeTLS().Get()); | |
| TSFBridgeTLS().Set(nullptr); | |
| delete delegate; | |
| } | |
| // static | |
| TSFBridge* TSFBridge::GetInstance() { | |
| if (!base::MessageLoopForUI::IsCurrent()) { | |
| DVLOG(1) << "Do not use TSFBridge without UI thread."; | |
| return nullptr; | |
| } | |
| TSFBridgeImpl* delegate = static_cast<TSFBridgeImpl*>(TSFBridgeTLS().Get()); | |
| DCHECK(delegate) << "Do no call GetInstance before TSFBridge::Initialize."; | |
| return delegate; | |
| } | |
| } // namespace ui |