ui: Use base::MessageLoop.

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 106 matching lines @@
 
 TSFBridgeDelegate::TSFBridgeDelegate()
     : client_id_(TF_CLIENTID_NULL),
       client_(NULL) {
 }
 
 TSFBridgeDelegate::~TSFBridgeDelegate() {
 }
 
 bool TSFBridgeDelegate::Initialize() {
-  DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
+  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))) {
     DVLOG(1) << "Failed to create ThreadManager instance.";
     return false;
   }
 
@@ skipping 27 matching lines @@
   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(MessageLoop::TYPE_UI, MessageLoop::current()->type());
+  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(MessageLoop::TYPE_UI, MessageLoop::current()->type());
+  DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
   DCHECK(IsInitialized());
 
   if (client != client_) {
     // Called from not focusing client. Do nothing.
     return;
   }
 
   thread_manager_->SetFocus(GetAssociatedDocumentManager().get());
 }
 
 bool TSFBridgeDelegate::CancelComposition() {
-  DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
+  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())) {
       focused_document_manager = it->second.document_manager.get();
       break;
     }
   }
@@ skipping 18 matching lines @@
     DVLOG(1) << "Failed to get ITfContextOwnerCompositionService.";
     return false;
   }
   // Cancel all compositions.
   owner->TerminateComposition(NULL);
   return true;
 }
 
 void TSFBridgeDelegate::SetFocusedClient(HWND focused_window,
                                          TextInputClient* client) {
-  DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
+  DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
   DCHECK(client);
   DCHECK(IsInitialized());
   client_ = client;
 
   for (TSFDocumentMap::iterator it = tsf_document_map_.begin();
        it != tsf_document_map_.end(); ++it) {
     if (it->second.text_store.get() == NULL)
       continue;
     it->second.text_store->SetFocusedTextInputClient(focused_window,
                                                      client);
   }
 
   // Synchronize text input type state.
   OnTextInputTypeChanged(client);
 }
 
 void TSFBridgeDelegate::RemoveFocusedClient(TextInputClient* client) {
-  DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
+  DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
   DCHECK(IsInitialized());
   if (client_ != client)
     return;
   client_ = NULL;
   for (TSFDocumentMap::iterator it = tsf_document_map_.begin();
         it != tsf_document_map_.end(); ++it) {
     if (it->second.text_store.get() == NULL)
       continue;
     it->second.text_store->SetFocusedTextInputClient(NULL, NULL);
   }
 }
 
 TextInputClient* TSFBridgeDelegate::GetFocusedTextInputClient() const {
   return client_;
 }
 
 base::win::ScopedComPtr<ITfThreadMgr> TSFBridgeDelegate::GetThreadManager() {
-  DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
+  DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
   DCHECK(IsInitialized());
   return thread_manager_;
 }
 
 bool TSFBridgeDelegate::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.";
@@ skipping 140 matching lines @@
 // TsfBridge  -----------------------------------------------------------------
 
 TSFBridge::TSFBridge() {
 }
 
 TSFBridge::~TSFBridge() {
 }
 
 // static
 bool TSFBridge::Initialize() {
-  if (MessageLoop::current()->type() != MessageLoop::TYPE_UI) {
+  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;
 }
 
 // static
 TSFBridge* TSFBridge::ReplaceForTesting(TSFBridge* bridge) {
-  if (MessageLoop::current()->type() != MessageLoop::TYPE_UI) {
+  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
 TSFBridge* TSFBridge::GetInstance() {
-  if (MessageLoop::current()->type() != MessageLoop::TYPE_UI) {
+  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