change TSFInputScope to have multiple InputScopes.

ui/base/ime/win/tsf_input_scope.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 "ui/base/ime/win/tsf_input_scope.h"
 
 #include <InputScope.h>
+#include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/win/windows_version.h"
 
 namespace ui {
 namespace tsf_inputscope {
 namespace {
 
 class TSFInputScope : public ITfInputScope {
  public:
-  explicit TSFInputScope(InputScope input_scope)
-      : input_scope_(input_scope),
-        ref_count_(0) {}
+  explicit TSFInputScope(InputScope* input_scope_list, size_t num_scopes)

[yukawa_g, 2013/07/31 09:44:52]

How about receiving std::vector<InputScope>?

+      : input_scope_list_(num_scopes),
+        ref_count_(0) {
+    for (size_t i = 0; i < num_scopes; i++)
+      input_scope_list_.push_back(input_scope_list[i]);
+  }
 
   // ITfInputScope:
   STDMETHOD_(ULONG, AddRef)() OVERRIDE {
     return InterlockedIncrement(&ref_count_);
   }
 
   STDMETHOD_(ULONG, Release)() OVERRIDE {
     const LONG count = InterlockedDecrement(&ref_count_);
     if (!count) {
       delete this;
@@ skipping 12 matching lines @@
       return E_NOINTERFACE;
     }
     AddRef();
     return S_OK;
   }
 
   STDMETHOD(GetInputScopes)(InputScope** input_scopes, UINT* count) OVERRIDE {
     if (!count || !input_scopes)
       return E_INVALIDARG;
     *input_scopes = static_cast<InputScope*>(CoTaskMemAlloc(
-        sizeof(InputScope)));
+        sizeof(InputScope) * input_scope_list_.size()));
     if (!input_scopes) {
       *count = 0;
       return E_OUTOFMEMORY;
     }
-    (*input_scopes)[0] = input_scope_;
-    *count = 1;
+
+    for (size_t i = 0; i < input_scope_list_.size(); ++i)
+      (*input_scopes)[i] = input_scope_list_[i];
+    *count = input_scope_list_.size();
     return S_OK;
   }
 
   STDMETHOD(GetPhrase)(BSTR** phrases, UINT* count) OVERRIDE {
     return E_NOTIMPL;
   }
 
   STDMETHOD(GetRegularExpression)(BSTR* regexp) OVERRIDE {
     return E_NOTIMPL;
   }
 
   STDMETHOD(GetSRGS)(BSTR* srgs) OVERRIDE {
     return E_NOTIMPL;
   }
 
   STDMETHOD(GetXML)(BSTR* xml) OVERRIDE {
     return E_NOTIMPL;
   }
 
  private:
-  // The corresponding text input type.
-  InputScope input_scope_;
+  // The corresponding text input types.
+  std::vector<InputScope> input_scope_list_;
 
   // The refrence count of this instance.
   volatile LONG ref_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TSFInputScope);
 };
 
 template <typename Proc>
 Proc GetTSFProcedure(const char* procedure_name) {
   static Proc procedure = NULL;
@@ skipping 70 matching lines @@
     case TEXT_INPUT_MODE_URL:
       return IS_URL;
     default:
       return IS_DEFAULT;
   }
 }
 
 }  // namespace
 
 ITfInputScope* CreateInputScope(TextInputType text_input_type) {
-  return new TSFInputScope(ConvertTextInputTypeToInputScope(text_input_type));
+  InputScope input_scopes[] = {
+      ConvertTextInputTypeToInputScope(text_input_type),

[yukawa_g, 2013/07/31 09:44:52]

nit: indent.

+  };
+  return new TSFInputScope(input_scopes, 1);
 }
 
 void SetInputScopeForTsfUnawareWindow(HWND window_handle,
                                       TextInputType text_input_type) {
   SetInputScopeFunc set_input_scope =
       GetTSFProcedure<SetInputScopeFunc>("SetInputScope");
   if (set_input_scope)
     set_input_scope(window_handle,
                     ConvertTextInputTypeToInputScope(text_input_type));
 }
@@ skipping 11 matching lines @@
     };
 
     set_input_scopes(window_handle, input_scopes,
                      (input_scopes[0] == input_scopes[1] ? 1 : 2), NULL, 0,
                      NULL, NULL);
   }
 }
 
 }  // namespace tsf_inputscope
 }  // namespace ui