Enable TsfBridge to re-initialize

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"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_local_storage.h"
 #include "base/win/scoped_comptr.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"
 
 namespace ui {
 
 namespace {
 
 // We use thread local storage for TSFBridge lifespan management.
 base::ThreadLocalStorage::StaticSlot tls_tsf_bridge = TLS_INITIALIZER;
 
 
 // TsfBridgeDelegate -----------------------------------------------------------
 
 // A TLS implementation of TSFBridge.
 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>;
-
   // 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
@@ skipping 52 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TSFBridgeDelegate);
 };
 
 TSFBridgeDelegate::TSFBridgeDelegate()
     : client_id_(TF_CLIENTID_NULL),
       client_(NULL) {
 }
 
 TSFBridgeDelegate::~TSFBridgeDelegate() {
+  DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
+  if (!IsInitialized())
+    return;
+  for (TSFDocumentMap::iterator it = tsf_document_map_.begin();
+       it != tsf_document_map_.end(); ++it) {
+    base::win::ScopedComPtr<ITfContext> context;
+    base::win::ScopedComPtr<ITfSource> source;
+    if (it->second.cookie != TF_INVALID_COOKIE &&
+        SUCCEEDED(it->second.document_manager->GetBase(context.Receive())) &&
+        SUCCEEDED(source.QueryFrom(context))) {
+      source->UnadviseSink(it->second.cookie);
+    }
+  }
+  tsf_document_map_.clear();
+
+  client_id_ = TF_CLIENTID_NULL;
 }
 
 bool TSFBridgeDelegate::Initialize() {
   DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
   if (client_id_ != TF_CLIENTID_NULL) {
     DVLOG(1) << "Already initialized.";
     return false;
   }
 
   if (FAILED(thread_manager_.CreateInstance(CLSID_TF_ThreadMgr))) {
@@ skipping 30 matching lines @@
   base::win::ScopedVariant sentence_variant;
   sentence_variant.Set(TF_SENTENCEMODE_PHRASEPREDICT);
   if (FAILED(sentence_compartment->SetValue(client_id_, &sentence_variant))) {
     DVLOG(1) << "Failed to change the sentence mode.";
     return false;
   }
 
   return true;
 }
 
-void TSFBridgeDelegate::Shutdown() {
-  DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
-  if (!IsInitialized())
-    return;
-  for (TSFDocumentMap::iterator it = tsf_document_map_.begin();
-       it != tsf_document_map_.end(); ++it) {
-    base::win::ScopedComPtr<ITfContext> context;
-    base::win::ScopedComPtr<ITfSource> source;
-    if (it->second.cookie != TF_INVALID_COOKIE &&
-        SUCCEEDED(it->second.document_manager->GetBase(context.Receive())) &&
-        SUCCEEDED(source.QueryFrom(context))) {
-      source->UnadviseSink(it->second.cookie);
-    }
-  }
-  tsf_document_map_.clear();
-
-  client_id_ = TF_CLIENTID_NULL;
-}
-
 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();
@@ skipping 249 matching lines @@
 }
 
 // static
 bool TSFBridge::Initialize() {
   if (base::MessageLoop::current()->type() != base::MessageLoop::TYPE_UI) {
     DVLOG(1) << "Do not use TSFBridge without UI thread.";
     return false;
   }
   if (!tls_tsf_bridge.initialized()) {
     tls_tsf_bridge.Initialize(TSFBridge::Finalize);
-    TSFBridgeDelegate* delegate = new TSFBridgeDelegate();
-    tls_tsf_bridge.Set(delegate);
-    return delegate->Initialize();
   }
-  return true;
+  TSFBridgeDelegate* delegate =
+      static_cast<TSFBridgeDelegate*>(tls_tsf_bridge.Get());
+  if (delegate)
+    return true;
+  delegate = new TSFBridgeDelegate();
+  tls_tsf_bridge.Set(delegate);
+  return delegate->Initialize();
 }
 
 // static
 TSFBridge* TSFBridge::ReplaceForTesting(TSFBridge* bridge) {
   if (base::MessageLoop::current()->type() != base::MessageLoop::TYPE_UI) {
     DVLOG(1) << "Do not use TSFBridge without UI thread.";
     return NULL;
   }
   TSFBridge* old_bridge = TSFBridge::GetInstance();
   tls_tsf_bridge.Set(bridge);
   return old_bridge;
 }
 
 // static
+void TSFBridge::Shutdown() {
+  if (base::MessageLoop::current()->type() != base::MessageLoop::TYPE_UI) {
+    DVLOG(1) << "Do not use TSFBridge without UI thread.";
+  }
+  if (tls_tsf_bridge.initialized()) {
+    TSFBridgeDelegate* delegate =
+        static_cast<TSFBridgeDelegate*>(tls_tsf_bridge.Get());
+    tls_tsf_bridge.Set(NULL);
+    delete delegate;
+  }
+}
+
+// static
 TSFBridge* TSFBridge::GetInstance() {
   if (base::MessageLoop::current()->type() != base::MessageLoop::TYPE_UI) {
     DVLOG(1) << "Do not use TSFBridge without UI thread.";
     return NULL;
   }
   TSFBridgeDelegate* delegate =
       static_cast<TSFBridgeDelegate*>(tls_tsf_bridge.Get());
   DCHECK(delegate) << "Do no call GetInstance before TSFBridge::Initialize.";
   return delegate;
 }
 
 // static
 void TSFBridge::Finalize(void* data) {
   TSFBridgeDelegate* delegate = static_cast<TSFBridgeDelegate*>(data);
   delete delegate;
 }
 
 }  // namespace ui