Create direct write font proxy classes and unit tests.

content/child/dwrite_font_proxy/dwrite_localized_strings_win.cc

+// Copyright 2015 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 "content/child/dwrite_font_proxy/dwrite_localized_strings_win.h"
+
+#include "base/logging.h"
+
+namespace content {
+
+DWriteLocalizedStrings::~DWriteLocalizedStrings() {}
+
+HRESULT DWriteLocalizedStrings::FindLocaleName(const WCHAR* locale_name,
+                                               UINT32* index,
+                                               BOOL* exists) {
+  for (unsigned int n = 0; n < strings_.size(); ++n) {

[Alexei Svitkine (slow), 2015/11/25 20:17:45]

Convention is to use size_t for std::vector indexes in Chromium code.

[Ilya Kulshin, 2015/12/02 02:23:01]

Done.

+    if (_wcsicmp(strings_[n].first.data(), locale_name) == 0) {
+      *index = n;
+      *exists = TRUE;
+      return S_OK;
+    }
+  }
+
+  *index = UINT_MAX;
+  *exists = FALSE;
+  return S_OK;
+}
+
+UINT32 DWriteLocalizedStrings::GetCount() {
+  return strings_.size();
+}
+
+HRESULT DWriteLocalizedStrings::GetLocaleName(UINT32 index,
+                                              WCHAR* locale_name,
+                                              UINT32 size) {
+  if (index >= strings_.size())
+    return E_INVALIDARG;
+  if (size <= strings_[index].first.size())

[Alexei Svitkine (slow), 2015/11/25 20:17:45]

If it's equal, shouldn't it be OK? Or is this to account for the null
terminator? If so, add a comment.

Also, if you're ensuring there's space for the null terminator, then please
ensure to add it. Same comments for GetString() below.

[Ilya Kulshin, 2015/12/02 02:23:01]

Done.

+    return E_INVALIDARG;
+  wcsncpy(locale_name, strings_[index].first.data(), size);

[Alexei Svitkine (slow), 2015/11/25 20:17:45]

This isn't correct. You're copying |size| bytes, but |size| is the size of the
buffer, not the size of the string!

You should use the size of the string and also ensure its null terminated.

After fixing this, please add a unit test (e.g. that tries to copy a small
string into a 1k buffer) that would have crashed the previous code.

[Ilya Kulshin, 2015/12/02 02:23:01]

wcsncpy will not overread the source (it will instead pad with null characters),
so |size| is safe to use. I prefer to use |size| as-is, to reduce the risk of
making a mistake while calculating an acceptable number of characters to copy.
Since we ensure that |size| is greater than the number of characters, wcsncpy
will also ensure that the output is null terminated.

I changed data() to c_str(), but that change is only for readability and will
have no effect (the two functions are equivalent).

+  return S_OK;
+}
+
+HRESULT DWriteLocalizedStrings::GetLocaleNameLength(UINT32 index,
+                                                    UINT32* length) {
+  if (index >= strings_.size())
+    return E_INVALIDARG;
+  *length = strings_[index].first.size();
+  return S_OK;
+}
+
+HRESULT DWriteLocalizedStrings::GetString(UINT32 index,
+                                          WCHAR* string_buffer,
+                                          UINT32 size) {
+  if (index >= strings_.size())
+    return E_INVALIDARG;
+  if (size <= strings_[index].second.size())
+    return E_INVALIDARG;
+  wcsncpy(string_buffer, strings_[index].second.data(), size);
+  return S_OK;
+}
+
+HRESULT DWriteLocalizedStrings::GetStringLength(UINT32 index, UINT32* length) {
+  if (index >= strings_.size())
+    return E_INVALIDARG;
+  *length = strings_[index].second.size();
+  return S_OK;
+}
+
+HRESULT DWriteLocalizedStrings::RuntimeClassInitialize(
+    std::vector<std::pair<base::string16, base::string16>>* strings) {
+  strings_.swap(*strings);
+  return S_OK;
+}
+
+}  // namespace content