Get IME's to work in Chrome OS mode on Windows 7.

win8/metro_driver/ime/text_service.cc

 // Copyright 2013 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 "win8/metro_driver/ime/text_service.h"
 
 #include <msctf.h>
 
 #include "base/logging.h"
 #include "base/win/scoped_variant.h"
@@ skipping 74 matching lines @@
 // about what will be involved in this multi-phase construction. See also
 // text_store.cc and input_scope.cc for more underlying details.
 
 namespace metro_driver {
 namespace {
 
 // Japanese IME expects the default value of this compartment is
 // TF_SENTENCEMODE_PHRASEPREDICT to emulate IMM32 behavior. This value is
 // managed per thread, thus setting this value at once is sufficient. This
 // value never affects non-Japanese IMEs.
-bool InitializeSentenceMode(ITfThreadMgr2* thread_manager,
+bool InitializeSentenceMode(ITfThreadMgr* thread_manager,
                             TfClientId client_id) {
   base::win::ScopedComPtr<ITfCompartmentMgr> thread_compartment_manager;
   HRESULT hr = thread_compartment_manager.QueryFrom(thread_manager);
   if (FAILED(hr)) {
     LOG(ERROR) << "QueryFrom failed. hr = " << hr;
     return false;
   }
   base::win::ScopedComPtr<ITfCompartment> sentence_compartment;
   hr = thread_compartment_manager->GetCompartment(
       GUID_COMPARTMENT_KEYBOARD_INPUTMODE_SENTENCE,
@@ skipping 111 matching lines @@
 //      TSF runtime and TextStore is unregistered when this object is destroyed.
 class DocumentBinding {
  public:
   ~DocumentBinding() {
     if (!document_manager_)
       return;
     document_manager_->Pop(TF_POPF_ALL);
   }
 
   static scoped_ptr<DocumentBinding> Create(
-      ITfThreadMgr2* thread_manager,
+      ITfThreadMgr* thread_manager,
       TfClientId client_id,
       const std::vector<InputScope>& input_scopes,
       HWND window_handle,
       TextStoreDelegate* delegate) {
     base::win::ScopedComPtr<ITfDocumentMgr> document_manager;
     HRESULT hr = thread_manager->CreateDocumentMgr(document_manager.Receive());
     if (FAILED(hr)) {
-      LOG(ERROR) << "ITfThreadMgr2::CreateDocumentMgr failed. hr = " << hr;
+      LOG(ERROR) << "ITfThreadMgr::CreateDocumentMgr failed. hr = " << hr;
       return scoped_ptr<DocumentBinding>();
     }
 
     // Note: In our IPC protocol, an empty |input_scopes| is used to indicate
     // that an IME must be disabled in this context. In such case, we need not
     // instantiate TextStore.
     const bool use_null_text_store = input_scopes.empty();
 
     scoped_refptr<TextStore> text_store;
     if (!use_null_text_store) {
@@ skipping 63 matching lines @@
   scoped_refptr<TextStore> text_store_;
   base::win::ScopedComPtr<ITfDocumentMgr> document_manager_;
   scoped_ptr<EventSink> text_edit_sink_;
 
   DISALLOW_COPY_AND_ASSIGN(DocumentBinding);
 };
 
 class TextServiceImpl : public TextService,
                         public TextStoreDelegate {
  public:
-  TextServiceImpl(ITfThreadMgr2* thread_manager,
+  TextServiceImpl(ITfThreadMgr* thread_manager,
                   TfClientId client_id,
                   HWND window_handle,
                   TextServiceDelegate* delegate)
       : client_id_(client_id),
         window_handle_(window_handle),
         delegate_(delegate),
         thread_manager_(thread_manager) {
     DCHECK_NE(TF_CLIENTID_NULL, client_id);
     DCHECK(window_handle != NULL);
     DCHECK(thread_manager_);
@@ skipping 31 matching lines @@
       VLOG(0) << "|current_document_| is NULL due to the previous error.";
       return;
     }
     ITfDocumentMgr* document_manager = current_document_->document_manager();
     if (!document_manager) {
       VLOG(0) << "|document_manager| is NULL due to the previous error.";
       return;
     }
     HRESULT hr = thread_manager_->SetFocus(document_manager);
     if (FAILED(hr)) {
-      LOG(ERROR) << "ITfThreadMgr2::SetFocus failed. hr = " << hr;
+      LOG(ERROR) << "ITfThreadMgr::SetFocus failed. hr = " << hr;
       return;
     }
   }
 
   virtual void OnCompositionChanged(
       const base::string16& text,
       int32 selection_start,
       int32 selection_end,
       const std::vector<metro_viewer::UnderlineInfo>& underlines) override {
     if (!delegate_)
@@ skipping 57 matching lines @@
                                 this);
     LOG_IF(ERROR, !new_document) << "Failed to create a new document.";
     current_document_.swap(new_document);
     OnWindowActivated();
   }
 
   TfClientId client_id_;
   HWND window_handle_;
   TextServiceDelegate* delegate_;
   scoped_ptr<DocumentBinding> current_document_;
-  base::win::ScopedComPtr<ITfThreadMgr2> thread_manager_;
+  base::win::ScopedComPtr<ITfThreadMgr> thread_manager_;
 
   // A vector of InputScope enumeration, which represents the document type of
   // the focused text field. Note that in our IPC message protocol, an empty
   // |input_scopes_| has special meaning that IMEs must be disabled on this
   // document.
   std::vector<int32> input_scopes_;
   // Character bounds of the composition. When there is no composition but this
   // vector is not empty, the first element contains the caret bounds.
   std::vector<metro_viewer::CharacterBounds> composition_character_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(TextServiceImpl);
 };
 
 }  // namespace
 
 scoped_ptr<TextService>
 CreateTextService(TextServiceDelegate* delegate, HWND window_handle) {
   if (!delegate)
     return scoped_ptr<TextService>();
-  base::win::ScopedComPtr<ITfThreadMgr2> thread_manager;
+  base::win::ScopedComPtr<ITfThreadMgr> thread_manager;
   HRESULT hr = thread_manager.CreateInstance(CLSID_TF_ThreadMgr);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to create instance of CLSID_TF_ThreadMgr. hr = "
                << hr;
     return scoped_ptr<TextService>();
   }
   TfClientId client_id = TF_CLIENTID_NULL;
-  hr = thread_manager->ActivateEx(&client_id, 0);
+  hr = thread_manager->Activate(&client_id);
   if (FAILED(hr)) {
-    LOG(ERROR) << "ITfThreadMgr2::ActivateEx failed. hr = " << hr;
+    LOG(ERROR) << "ITfThreadMgr::Activate failed. hr = " << hr;
     return scoped_ptr<TextService>();
   }
   if (!InitializeSentenceMode(thread_manager, client_id)) {
     LOG(ERROR) << "InitializeSentenceMode failed.";
     thread_manager->Deactivate();
     return scoped_ptr<TextService>();
   }
   return scoped_ptr<TextService>(new TextServiceImpl(thread_manager,
                                                      client_id,
                                                      window_handle,
                                                      delegate));
 }
 
 }  // namespace metro_driver