Removes MessageLoop::Type checks in favor of IsCurrent on MessageLoops.

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 123 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TSFBridgeDelegate);
 };
 
 TSFBridgeDelegate::TSFBridgeDelegate()
     : client_id_(TF_CLIENTID_NULL),
       client_(NULL),
       attached_window_handle_(NULL) {
 }
 
 TSFBridgeDelegate::~TSFBridgeDelegate() {
-  DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
+  DCHECK(base::MessageLoopForUI::IsCurrent());
   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());
+  DCHECK(base::MessageLoopForUI::IsCurrent());
   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::OnTextInputTypeChanged(const TextInputClient* client) {
-  DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
+  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 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(base::MessageLoopForUI::IsCurrent());
   DCHECK(IsInitialized());
 
   TSFDocument* document = GetAssociatedDocument();
   if (!document)
     return false;
   if (!document->text_store)
     return false;
 
   return document->text_store->CancelComposition();
 }
 
 bool TSFBridgeDelegate::ConfirmComposition() {
-  DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
+  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 TSFBridgeDelegate::SetFocusedClient(HWND focused_window,
                                          TextInputClient* client) {
-  DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
+  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() == NULL)
       continue;
     it->second.text_store->SetFocusedTextInputClient(focused_window,
                                                      client);
   }
 
   // Synchronize text input type state.
   OnTextInputTypeChanged(client);
 }
 
 void TSFBridgeDelegate::RemoveFocusedClient(TextInputClient* client) {
-  DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
+  DCHECK(base::MessageLoopForUI::IsCurrent());
   DCHECK(IsInitialized());
   if (client_ != client)
     return;
   ClearAssociateFocus();
   client_ = NULL;
   attached_window_handle_ = 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(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type());
+  DCHECK(base::MessageLoopForUI::IsCurrent());
   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 173 matching lines @@
 // TsfBridge  -----------------------------------------------------------------
 
 TSFBridge::TSFBridge() {
 }
 
 TSFBridge::~TSFBridge() {
 }
 
 // static
 bool TSFBridge::Initialize() {
-  if (base::MessageLoop::current()->type() != base::MessageLoop::TYPE_UI) {
+  if (!base::MessageLoopForUI::IsCurrent()) {
     DVLOG(1) << "Do not use TSFBridge without UI thread.";
     return false;
   }
   if (!tls_tsf_bridge.initialized()) {
     tls_tsf_bridge.Initialize(TSFBridge::Finalize);
   }
   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) {
+  if (!base::MessageLoopForUI::IsCurrent()) {
     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) {
+  if (!base::MessageLoopForUI::IsCurrent()) {
     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) {
+  if (!base::MessageLoopForUI::IsCurrent()) {
     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