Initial import of the Chrome Frame codebase. Integration in chrome.gyp coming...

chrome_frame/icu_stubs.cc

Index: chrome_frame/icu_stubs.cc
===================================================================
--- chrome_frame/icu_stubs.cc	(revision 0)
+++ chrome_frame/icu_stubs.cc	(revision 0)
@@ -0,0 +1,169 @@
+// Copyright (c) 2009 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 "base/logging.h"
+#include "base/string_util.h"
+#include "googleurl/src/url_canon.h"
+
+#include <windows.h>
+
+////////////////////////////////////////////////////////////////////////////////
+// Avoid dependency on string_util_icu.cc (which pulls in icu).
+
+std::string WideToAnsiDirect(const wchar_t* wide, size_t wide_len) {
+  std::string ret;
+  char* write = WriteInto(&ret, wide_len + 1);
+  for (size_t i = 0; i < wide_len; ++i) {
+    // We can only convert characters below 0x80 directly from wide to ansi.
+    DCHECK(wide[i] <= 127) << "can't convert";
+    write[i] = static_cast<char>(wide[i]);
+  }
+
+  write[wide_len] = '\0';
+
+  return ret;
+}
+
+bool WideToUTF8(const wchar_t* wide, size_t wide_len, std::string* utf8) {
+  DCHECK(utf8);
+
+  // Add a cutoff. If it's all ASCII, convert it directly
+  size_t i;
+  for (i = 0; i < wide_len; ++i) {
+    if (wide[i] > 127)
+      break;
+  }
+
+  // If we made it to the end without breaking, then it's all ANSI, so do a
+  // quick convert
+  if (i == wide_len) {
+    *utf8 = WideToAnsiDirect(wide, wide_len);
+    return true;
+  }
+
+  // Figure out how long the string is
+  int size = WideCharToMultiByte(CP_UTF8, 0, wide, wide_len + 1, NULL, 0, NULL,
+                                 NULL);
+
+  if (size > 0) {
+    WideCharToMultiByte(CP_UTF8, 0, wide, wide_len + 1, WriteInto(utf8, size),
+                        size, NULL, NULL);
+  }
+
+  return (size > 0);
+}
+
+std::string WideToUTF8(const std::wstring& wide) {
+  std::string ret;
+  if (!wide.empty()) {
+    // Ignore the success flag of this call, it will do the best it can for
+    // invalid input, which is what we want here.
+    WideToUTF8(wide.data(), wide.length(), &ret);
+  }
+  return ret;
+}
+
+bool UTF8ToWide(const char* src, size_t src_len, std::wstring* output) {
+  DCHECK(output);
+
+  if (src_len == 0) {
+    output->clear();
+    return true;
+  }
+
+  int wide_chars = MultiByteToWideChar(CP_UTF8, 0, src, src_len, NULL, 0);
+  if (!wide_chars) {
+    NOTREACHED();
+    return false;
+  }
+
+  wide_chars++;  // make room for L'\0'
+  // Note that WriteInto will fill the string with '\0', so in the case
+  // where the input string is not \0 terminated, we will still be ensured
+  // that the output string will be.
+  if (!MultiByteToWideChar(CP_UTF8, 0, src, src_len,
+                           WriteInto(output, wide_chars), wide_chars)) {
+    NOTREACHED();
+    output->clear();
+    return false;
+  }
+
+  return true;
+}
+
+std::wstring UTF8ToWide(const base::StringPiece& utf8) {
+  std::wstring ret;
+  if (!utf8.empty())
+    UTF8ToWide(utf8.data(), utf8.length(), &ret);
+  return ret;
+}
+
+#ifdef WCHAR_T_IS_UTF16
+string16 UTF8ToUTF16(const std::string& utf8) {
+  std::wstring ret;
+  if (!utf8.empty())
+    UTF8ToWide(utf8.data(), utf8.length(), &ret);
+  return ret;
+}
+#else
+#error Need WCHAR_T_IS_UTF16
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Replace ICU dependent functions in googleurl.
+/*#define __UTF_H__
+#include "third_party/icu38/public/common/unicode/utf16.h"
+#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800)
+extern const char16 kUnicodeReplacementCharacter;*/
+
+namespace url_canon {
+
+bool IDNToASCII(const char16* src, int src_len, CanonOutputW* output) {
+  // We should only hit this when the user attempts to navigate
+  // CF to an invalid URL.
+  DLOG(WARNING) << __FUNCTION__ << " not implemented";
+  return false;
+}
+
+bool ReadUTFChar(const char* str, int* begin, int length,
+                 unsigned* code_point_out) {
+  // We should only hit this when the user attempts to navigate
+  // CF to an invalid URL.
+  DLOG(WARNING) << __FUNCTION__ << " not implemented";
+
+  // TODO(tommi): consider if we can use something like
+  // http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+  return false;
+}
+
+bool ReadUTFChar(const char16* str, int* begin, int length,
+                 unsigned* code_point) {
+/*
+  if (U16_IS_SURROGATE(str[*begin])) {
+    if (!U16_IS_SURROGATE_LEAD(str[*begin]) || *begin + 1 >= length ||
+        !U16_IS_TRAIL(str[*begin + 1])) {
+      // Invalid surrogate pair.
+      *code_point = kUnicodeReplacementCharacter;
+      return false;
+    } else {
+      // Valid surrogate pair.
+      *code_point = U16_GET_SUPPLEMENTARY(str[*begin], str[*begin + 1]);
+      (*begin)++;
+    }
+  } else {
+    // Not a surrogate, just one 16-bit word.
+    *code_point = str[*begin];
+  }
+
+  if (U_IS_UNICODE_CHAR(*code_point))
+    return true;
+
+  // Invalid code point.
+  *code_point = kUnicodeReplacementCharacter;
+  return false;*/
+  CHECK(false);
+  return false;
+}
+
+}  // namespace url_canon