Make InputMethodWin TSF-aware.

ui/base/ime/win/tsf_bridge.cc

 // Copyright (c) 2012 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"
@@ skipping 21 matching lines @@
 class TSFBridgeDelegate : public TSFBridge {
  public:
   TSFBridgeDelegate();
   virtual ~TSFBridgeDelegate();
 
   bool Initialize();
 
   // TsfBridge:
   virtual void Shutdown() OVERRIDE;
   virtual void OnTextInputTypeChanged(TextInputClient* client) OVERRIDE;
+  virtual void OnTextLayoutChanged() OVERRIDE;
   virtual bool CancelComposition() OVERRIDE;
   virtual void SetFocusedClient(HWND focused_window,
                                 TextInputClient* client) OVERRIDE;
   virtual void RemoveFocusedClient(TextInputClient* client) OVERRIDE;
   virtual base::win::ScopedComPtr<ITfThreadMgr> GetThreadManager() OVERRIDE;
   virtual TextInputClient* GetFocusedTextInputClient() const OVERRIDE;
 
  private:
   friend struct DefaultSingletonTraits<TSFBridgeDelegate>;
 
@@ skipping 15 matching lines @@
                              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();
 
-  // Returns an instance of ITfDocumentMgr that is associated with the
-  // current TextInputType of |client_|.
-  base::win::ScopedComPtr<ITfDocumentMgr> GetAssociatedDocumentManager();
-
-  // An ITfThreadMgr object to be used in focus and document management.
-  base::win::ScopedComPtr<ITfThreadMgr> thread_manager_;
-
   // 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) {}
     base::win::ScopedComPtr<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.
+  base::win::ScopedComPtr<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
+  // that is not converted 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_;
 
@@ skipping 79 matching lines @@
 }
 
 void TSFBridgeDelegate::OnTextInputTypeChanged(TextInputClient* client) {
   DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
   DCHECK(IsInitialized());
 
   if (client != client_) {
     // Called from not focusing client. Do nothing.
     return;
   }
+  TSFDocument* document = GetAssociatedDocument();
+  if (!document)
+    return;
+  thread_manager_->SetFocus(document->document_manager.get());
+  OnTextLayoutChanged();
+}
 
-  thread_manager_->SetFocus(GetAssociatedDocumentManager().get());
+void TSFBridgeDelegate::OnTextLayoutChanged() {
+  TSFDocument* document = GetAssociatedDocument();
+  if (!document)
+    return;
+  if (!document->text_store)
+    return;
+  document->text_store->SendOnLayoutChange();
 }
 
 bool TSFBridgeDelegate::CancelComposition() {
   DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
   DCHECK(IsInitialized());
 
   base::win::ScopedComPtr<ITfDocumentMgr> focused_document_manager;
   for (TSFDocumentMap::iterator it = tsf_document_map_.begin();
        it != tsf_document_map_.end(); ++it) {
     if (IsFocused(it->second.document_manager.get())) {
@@ skipping 197 matching lines @@
   base::win::ScopedComPtr<ITfDocumentMgr> focused_document_manager;
   if (FAILED(thread_manager_->GetFocus(focused_document_manager.Receive())))
     return false;
   return focused_document_manager.IsSameObject(document_manager);
 }
 
 bool TSFBridgeDelegate::IsInitialized() {
   return client_id_ != TF_CLIENTID_NULL;
 }
 
-base::win::ScopedComPtr<ITfDocumentMgr>
-TSFBridgeDelegate::GetAssociatedDocumentManager() {
-  TSFDocumentMap::const_iterator it =
+TSFBridgeDelegate::TSFDocument* TSFBridgeDelegate::GetAssociatedDocument() {
+  if (!client_)
+    return NULL;
+  TSFDocumentMap::iterator it =
       tsf_document_map_.find(client_->GetTextInputType());
   if (it == tsf_document_map_.end())
-    return tsf_document_map_[TEXT_INPUT_TYPE_TEXT].document_manager;
-  return it->second.document_manager;
+    return &tsf_document_map_[TEXT_INPUT_TYPE_TEXT];
+  return &it->second;
 }
 
 }  // namespace
 
 
 // TsfBridge  -----------------------------------------------------------------
 
 TSFBridge::TSFBridge() {
 }
 
@@ skipping 38 matching lines @@
   return delegate;
 }
 
 // static
 void TSFBridge::Finalize(void* data) {
   TSFBridgeDelegate* delegate = static_cast<TSFBridgeDelegate*>(data);
   delete delegate;
 }
 
 }  // namespace ui