Move color_utils, text_elider, drag_utils, accessibility_types, standard_layout to new locations in app/ and views/

http://crbug.com/11387
Review URL: http://codereview.chromium.org/113143

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@15687 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 1479 insertions, 248 deletions

diff --git a/app/DEPS b/app/DEPS
index 6e1991a..b3eb1d8 100644
--- a/app/DEPS
+++ b/app/DEPS
@@ -8,7 +8,10 @@ include_rules = [
   "+chrome/common/chrome_paths.h",
   "+chrome/common/chrome_switches.h",
   "+chrome/common/gtk_util.h",
-  
+  # text_elider.cc
+  "+chrome/common/pref_names.h",
+  "+chrome/common/pref_service.h",
+    
   # TODO(beng): l10n_util_unittest.cc:
   "+chrome/test/data/resource.h",  
   
diff --git a/app/app.vcproj b/app/app.vcproj
index ad6a6eb..cb2892f 100644
--- a/app/app.vcproj
+++ b/app/app.vcproj
@@ -1,247 +1,263 @@
-<?xml version="1.0" encoding="Windows-1252"?>

-<VisualStudioProject

-	ProjectType="Visual C++"

-	Version="8.00"

-	Name="app"

-	ProjectGUID="{4631946D-7D5F-44BD-A5A8-504C0A7033BE}"

-	RootNamespace="app"

-	Keyword="Win32Proj"

-	>

-	<Platforms>

-		<Platform

-			Name="Win32"

-		/>

-	</Platforms>

-	<ToolFiles>

-	</ToolFiles>

-	<Configurations>

-		<Configuration

-			Name="Debug|Win32"

-			ConfigurationType="4"

-			InheritedPropertySheets=".\app.vsprops;$(SolutionDir)..\build\debug.vsprops"

-			>

-			<Tool

-				Name="VCPreBuildEventTool"

-			/>

-			<Tool

-				Name="VCCustomBuildTool"

-			/>

-			<Tool

-				Name="VCXMLDataGeneratorTool"

-			/>

-			<Tool

-				Name="VCWebServiceProxyGeneratorTool"

-			/>

-			<Tool

-				Name="VCMIDLTool"

-			/>

-			<Tool

-				Name="VCCLCompilerTool"

-			/>

-			<Tool

-				Name="VCManagedResourceCompilerTool"

-			/>

-			<Tool

-				Name="VCResourceCompilerTool"

-			/>

-			<Tool

-				Name="VCPreLinkEventTool"

-			/>

-			<Tool

-				Name="VCLibrarianTool"

-			/>

-			<Tool

-				Name="VCALinkTool"

-			/>

-			<Tool

-				Name="VCXDCMakeTool"

-			/>

-			<Tool

-				Name="VCBscMakeTool"

-			/>

-			<Tool

-				Name="VCFxCopTool"

-			/>

-			<Tool

-				Name="VCPostBuildEventTool"

-			/>

-		</Configuration>

-		<Configuration

-			Name="Release|Win32"

-			ConfigurationType="4"

-			InheritedPropertySheets=".\app.vsprops;$(SolutionDir)..\build\release.vsprops"

-			>

-			<Tool

-				Name="VCPreBuildEventTool"

-			/>

-			<Tool

-				Name="VCCustomBuildTool"

-			/>

-			<Tool

-				Name="VCXMLDataGeneratorTool"

-			/>

-			<Tool

-				Name="VCWebServiceProxyGeneratorTool"

-			/>

-			<Tool

-				Name="VCMIDLTool"

-			/>

-			<Tool

-				Name="VCCLCompilerTool"

-			/>

-			<Tool

-				Name="VCManagedResourceCompilerTool"

-			/>

-			<Tool

-				Name="VCResourceCompilerTool"

-			/>

-			<Tool

-				Name="VCPreLinkEventTool"

-			/>

-			<Tool

-				Name="VCLibrarianTool"

-			/>

-			<Tool

-				Name="VCALinkTool"

-			/>

-			<Tool

-				Name="VCXDCMakeTool"

-			/>

-			<Tool

-				Name="VCBscMakeTool"

-			/>

-			<Tool

-				Name="VCFxCopTool"

-			/>

-			<Tool

-				Name="VCPostBuildEventTool"

-			/>

-		</Configuration>

-	</Configurations>

-	<References>

-	</References>

-	<Files>

-		<Filter

-			Name="gfx"

-			>

-			<File

-				RelativePath=".\gfx\chrome_canvas.cc"

-				>

-			</File>

-			<File

-				RelativePath=".\gfx\chrome_canvas.h"

-				>

-			</File>

-			<File

-				RelativePath=".\gfx\chrome_canvas_win.cc"

-				>

-			</File>

-			<File

-				RelativePath=".\gfx\chrome_font.h"

-				>

-			</File>

-			<File

-				RelativePath=".\gfx\chrome_font_win.cc"

-				>

-			</File>

-			<File

-				RelativePath=".\gfx\favicon_size.h"

-				>

-			</File>

-			<File

-				RelativePath=".\gfx\icon_util.cc"

-				>

-			</File>

-			<File

-				RelativePath=".\gfx\icon_util.h"

-				>

-			</File>

-			<File

-				RelativePath=".\gfx\insets.h"

-				>

-			</File>

-			<File

-				RelativePath=".\gfx\path.h"

-				>

-			</File>

-			<File

-				RelativePath=".\gfx\path_win.cc"

-				>

-			</File>

-		</Filter>

-		<File

-			RelativePath=".\animation.cc"

-			>

-		</File>

-		<File

-			RelativePath=".\animation.h"

-			>

-		</File>

-		<File

-			RelativePath=".\drag_drop_types.cc"

-			>

-		</File>

-		<File

-			RelativePath=".\drag_drop_types.h"

-			>

-		</File>

-		<File

-			RelativePath=".\l10n_util.cc"

-			>

-		</File>

-		<File

-			RelativePath=".\l10n_util.h"

-			>

-		</File>

-		<File

-			RelativePath=".\l10n_util_win.cc"

-			>

-		</File>

-		<File

-			RelativePath=".\l10n_util_win.h"

-			>

-		</File>

-		<File

-			RelativePath=".\message_box_flags.h"

-			>

-		</File>

-		<File

-			RelativePath=".\os_exchange_data.cc"

-			>

-		</File>

-		<File

-			RelativePath=".\os_exchange_data.h"

-			>

-		</File>

-		<File

-			RelativePath=".\resource_bundle.cc"

-			>

-		</File>

-		<File

-			RelativePath=".\resource_bundle.h"

-			>

-		</File>

-		<File

-			RelativePath=".\resource_bundle_win.cc"

-			>

-		</File>

-		<File

-			RelativePath=".\slide_animation.cc"

-			>

-		</File>

-		<File

-			RelativePath=".\slide_animation.h"

-			>

-		</File>

-		<File

-			RelativePath=".\throb_animation.cc"

-			>

-		</File>

-		<File

-			RelativePath=".\throb_animation.h"

-			>

-		</File>

-	</Files>

-	<Globals>

-	</Globals>

-</VisualStudioProject>

+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="app"
+	ProjectGUID="{4631946D-7D5F-44BD-A5A8-504C0A7033BE}"
+	RootNamespace="app"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="4"
+			InheritedPropertySheets=".\app.vsprops;$(SolutionDir)..\build\debug.vsprops"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="4"
+			InheritedPropertySheets=".\app.vsprops;$(SolutionDir)..\build\release.vsprops"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="gfx"
+			>
+			<File
+				RelativePath=".\gfx\chrome_canvas.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\chrome_canvas.h"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\chrome_canvas_win.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\chrome_font.h"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\chrome_font_win.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\color_utils.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\color_utils.h"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\favicon_size.h"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\icon_util.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\icon_util.h"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\insets.h"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\path.h"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\path_win.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\text_elider.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\gfx\text_elider.h"
+				>
+			</File>
+		</Filter>
+		<File
+			RelativePath=".\animation.cc"
+			>
+		</File>
+		<File
+			RelativePath=".\animation.h"
+			>
+		</File>
+		<File
+			RelativePath=".\drag_drop_types.cc"
+			>
+		</File>
+		<File
+			RelativePath=".\drag_drop_types.h"
+			>
+		</File>
+		<File
+			RelativePath=".\l10n_util.cc"
+			>
+		</File>
+		<File
+			RelativePath=".\l10n_util.h"
+			>
+		</File>
+		<File
+			RelativePath=".\l10n_util_win.cc"
+			>
+		</File>
+		<File
+			RelativePath=".\l10n_util_win.h"
+			>
+		</File>
+		<File
+			RelativePath=".\message_box_flags.h"
+			>
+		</File>
+		<File
+			RelativePath=".\os_exchange_data.cc"
+			>
+		</File>
+		<File
+			RelativePath=".\os_exchange_data.h"
+			>
+		</File>
+		<File
+			RelativePath=".\resource_bundle.cc"
+			>
+		</File>
+		<File
+			RelativePath=".\resource_bundle.h"
+			>
+		</File>
+		<File
+			RelativePath=".\resource_bundle_win.cc"
+			>
+		</File>
+		<File
+			RelativePath=".\slide_animation.cc"
+			>
+		</File>
+		<File
+			RelativePath=".\slide_animation.h"
+			>
+		</File>
+		<File
+			RelativePath=".\throb_animation.cc"
+			>
+		</File>
+		<File
+			RelativePath=".\throb_animation.h"
+			>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/app/gfx/color_utils.cc b/app/gfx/color_utils.cc
new file mode 100644
index 0000000..6378723
--- /dev/null
+++ b/app/gfx/color_utils.cc
@@ -0,0 +1,266 @@
+// Copyright (c) 2006-2008 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 "app/gfx/color_utils.h"
+
+#include <math.h>
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "build/build_config.h"
+#if defined(OS_WIN)
+#include "skia/ext/skia_utils_win.h"
+#endif
+#include "skia/include/SkBitmap.h"
+
+namespace color_utils {
+
+// These transformations are based on the equations in:
+// http://en.wikipedia.org/wiki/Lab_color
+// http://en.wikipedia.org/wiki/SRGB_color_space#Specification_of_the_transformation
+// See also:
+// http://www.brucelindbloom.com/index.html?ColorCalculator.html
+
+static const double kCIEConversionAlpha = 0.055;
+static const double kCIEConversionGamma = 2.2;
+static const double kE = 0.008856;
+static const double kK = 903.3;
+
+static double CIEConvertNonLinear(uint8 color_component) {
+  double color_component_d = static_cast<double>(color_component) / 255.0;
+  if (color_component_d > 0.04045) {
+    double base = (color_component_d + kCIEConversionAlpha) /
+                      (1 + kCIEConversionAlpha);
+    return pow(base, kCIEConversionGamma);
+  } else {
+    return color_component_d / 12.92;
+  }
+}
+
+// Note: this works only for sRGB.
+void SkColorToCIEXYZ(SkColor c, CIE_XYZ* xyz) {
+  uint8 r = SkColorGetR(c);
+  uint8 g = SkColorGetG(c);
+  uint8 b = SkColorGetB(c);
+
+  xyz->X =
+    0.4124 * CIEConvertNonLinear(r) +
+    0.3576 * CIEConvertNonLinear(g) +
+    0.1805 * CIEConvertNonLinear(b);
+  xyz->Y =
+    0.2126 * CIEConvertNonLinear(r) +
+    0.7152 * CIEConvertNonLinear(g) +
+    0.0722 * CIEConvertNonLinear(g);
+  xyz->Z =
+    0.0193 * CIEConvertNonLinear(r) +
+    0.1192 * CIEConvertNonLinear(g) +
+    0.9505 * CIEConvertNonLinear(b);
+}
+
+static double LabConvertNonLinear(double value) {
+  if (value > 0.008856) {
+    double goat = pow(value, static_cast<double>(1) / 3);
+    return goat;
+  }
+  return (kK * value + 16) / 116;
+}
+
+void CIEXYZToLabColor(const CIE_XYZ& xyz, LabColor* lab) {
+  CIE_XYZ white_xyz;
+  SkColorToCIEXYZ(SkColorSetRGB(255, 255, 255), &white_xyz);
+  double fx = LabConvertNonLinear(xyz.X / white_xyz.X);
+  double fy = LabConvertNonLinear(xyz.Y / white_xyz.Y);
+  double fz = LabConvertNonLinear(xyz.Z / white_xyz.Z);
+  lab->L = static_cast<int>(116 * fy) - 16;
+  lab->a = static_cast<int>(500 * (fx - fy));
+  lab->b = static_cast<int>(200 * (fy - fz));
+}
+
+static uint8 sRGBColorComponentFromLinearComponent(double component) {
+  double result;
+  if (component <= 0.0031308) {
+    result = 12.92 * component;
+  } else {
+    result = (1 + kCIEConversionAlpha) *
+                 pow(component, (static_cast<double>(1) / 2.4)) -
+                 kCIEConversionAlpha;
+  }
+  return std::min(static_cast<uint8>(255), static_cast<uint8>(result * 255));
+}
+
+SkColor CIEXYZToSkColor(SkAlpha alpha, const CIE_XYZ& xyz) {
+  double r_linear = 3.2410 * xyz.X - 1.5374 * xyz.Y - 0.4986 * xyz.Z;
+  double g_linear = -0.9692 * xyz.X + 1.8760 * xyz.Y + 0.0416 * xyz.Z;
+  double b_linear = 0.0556 * xyz.X - 0.2040 * xyz.Y + 1.0570 * xyz.Z;
+  uint8 r = sRGBColorComponentFromLinearComponent(r_linear);
+  uint8 g = sRGBColorComponentFromLinearComponent(g_linear);
+  uint8 b = sRGBColorComponentFromLinearComponent(b_linear);
+  return SkColorSetARGB(alpha, r, g, b);
+}
+
+static double gen_yr(const LabColor& lab) {
+  if (lab.L > (kE * kK))
+    return pow((lab.L + 16.0) / 116, 3.0);
+  return static_cast<double>(lab.L) / kK;
+}
+
+static double fy(const LabColor& lab) {
+  double yr = gen_yr(lab);
+  if (yr > kE)
+    return (lab.L + 16.0) / 116;
+  return (kK * yr + 16.0) / 116;
+}
+
+static double fx(const LabColor& lab) {
+  return (static_cast<double>(lab.a) / 500) + fy(lab);
+}
+
+static double gen_xr(const LabColor& lab) {
+  double x = fx(lab);
+  double x_cubed = pow(x, 3.0);
+  if (x_cubed > kE)
+    return x_cubed;
+  return (116.0 * x - 16.0) / kK;
+}
+
+static double fz(const LabColor& lab) {
+  return fy(lab) - (static_cast<double>(lab.b) / 200);
+}
+
+static double gen_zr(const LabColor& lab) {
+  double z = fz(lab);
+  double z_cubed = pow(z, 3.0);
+  if (z_cubed > kE)
+    return z_cubed;
+  return (116.0 * z - 16.0) / kK;
+}
+
+void LabColorToCIEXYZ(const LabColor& lab, CIE_XYZ* xyz) {
+  CIE_XYZ result;
+
+  CIE_XYZ white_xyz;
+  SkColorToCIEXYZ(SkColorSetRGB(255, 255, 255), &white_xyz);
+
+  result.X = gen_xr(lab) * white_xyz.X;
+  result.Y = gen_yr(lab) * white_xyz.Y;
+  result.Z = gen_zr(lab) * white_xyz.Z;
+
+  *xyz = result;
+}
+
+void SkColorToLabColor(SkColor c, LabColor* lab) {
+  CIE_XYZ xyz;
+  SkColorToCIEXYZ(c, &xyz);
+  CIEXYZToLabColor(xyz, lab);
+}
+
+SkColor LabColorToSkColor(const LabColor& lab, SkAlpha alpha) {
+  CIE_XYZ xyz;
+  LabColorToCIEXYZ(lab, &xyz);
+  return CIEXYZToSkColor(alpha, xyz);
+}
+
+static const int kCloseToBoundary = 64;
+static const int kAverageBoundary = 15;
+
+bool IsColorCloseToTransparent(SkAlpha alpha) {
+  return alpha < kCloseToBoundary;
+}
+
+bool IsColorCloseToGrey(int r, int g, int b) {
+  int average = (r + g + b) / 3;
+  return (abs(r - average) < kAverageBoundary) &&
+         (abs(g - average) < kAverageBoundary) &&
+         (abs(b - average) < kAverageBoundary);
+}
+
+SkColor GetAverageColorOfFavicon(SkBitmap* favicon, SkAlpha alpha) {
+  int r = 0, g = 0, b = 0;
+
+  SkAutoLockPixels favicon_lock(*favicon);
+  SkColor* pixels = static_cast<SkColor*>(favicon->getPixels());
+  // Assume ARGB_8888 format.
+  DCHECK(favicon->getConfig() == SkBitmap::kARGB_8888_Config);
+  SkColor* current_color = pixels;
+
+  DCHECK(favicon->width() <= 16 && favicon->height() <= 16);
+
+  int pixel_count = favicon->width() * favicon->height();
+  int color_count = 0;
+  for (int i = 0; i < pixel_count; ++i, ++current_color) {
+    // Disregard this color if it is close to black, close to white, or close
+    // to transparent since any of those pixels do not contribute much to the
+    // color makeup of this icon.
+    int cr = SkColorGetR(*current_color);
+    int cg = SkColorGetG(*current_color);
+    int cb = SkColorGetB(*current_color);
+
+    if (IsColorCloseToTransparent(SkColorGetA(*current_color)) ||
+        IsColorCloseToGrey(cr, cg, cb))
+      continue;
+
+    r += cr;
+    g += cg;
+    b += cb;
+    ++color_count;
+  }
+
+  SkColor result;
+  if (color_count > 0) {
+    result = SkColorSetARGB(alpha,
+                            r / color_count,
+                            g / color_count,
+                            b / color_count);
+  } else {
+    result = SkColorSetARGB(alpha, 0, 0, 0);
+  }
+  return result;
+}
+
+inline int GetLumaForColor(SkColor* color) {
+  int r = SkColorGetR(*color);
+  int g = SkColorGetG(*color);
+  int b = SkColorGetB(*color);
+
+  int luma = static_cast<int>(0.3*r + 0.59*g + 0.11*b);
+  if (luma < 0)
+    luma = 0;
+  else if (luma > 255)
+    luma = 255;
+
+  return luma;
+}
+
+void BuildLumaHistogram(SkBitmap* bitmap, int histogram[256]) {
+  SkAutoLockPixels bitmap_lock(*bitmap);
+  // Assume ARGB_8888 format.
+  DCHECK(bitmap->getConfig() == SkBitmap::kARGB_8888_Config);
+
+  int pixel_width = bitmap->width();
+  int pixel_height = bitmap->height();
+  for (int y = 0; y < pixel_height; ++y) {
+    SkColor* current_color = static_cast<uint32_t*>(bitmap->getAddr32(0, y));
+    for (int x = 0; x < pixel_width; ++x, ++current_color) {
+      histogram[GetLumaForColor(current_color)]++;
+    }
+  }
+}
+
+SkColor SetColorAlpha(SkColor c, SkAlpha alpha) {
+  return SkColorSetARGB(alpha, SkColorGetR(c), SkColorGetG(c), SkColorGetB(c));
+}
+
+SkColor GetSysSkColor(int which) {
+#if defined(OS_WIN)
+  return skia::COLORREFToSkColor(::GetSysColor(which));
+#else
+  NOTIMPLEMENTED();
+  return SK_ColorLTGRAY;
+#endif
+}
+
+} // namespace color_utils
diff --git a/app/gfx/color_utils.h b/app/gfx/color_utils.h
new file mode 100644
index 0000000..706361d
--- /dev/null
+++ b/app/gfx/color_utils.h
@@ -0,0 +1,63 @@
+// Copyright (c) 2006-2008 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.
+
+#ifndef APP_GFX_COLOR_UTILS_H_
+#define APP_GFX_COLOR_UTILS_H_
+
+#include "skia/include/SkColor.h"
+
+class SkBitmap;
+
+namespace color_utils {
+
+// Represents set of CIE XYZ tristimulus values.
+struct CIE_XYZ {
+  double X;
+  double Y; // luminance
+  double Z;
+};
+
+// Represents a L*a*b* color value
+struct LabColor {
+  int L;
+  int a;
+  int b;
+};
+
+// Note: these transformations assume sRGB as the source color space
+
+// Convert between different color spaces
+void SkColorToCIEXYZ(SkColor c, CIE_XYZ* xyz);
+void CIEXYZToLabColor(const CIE_XYZ& xyz, LabColor* lab);
+
+SkColor CIEXYZToSkColor(SkAlpha alpha, const CIE_XYZ& xyz);
+void LabColorToCIEXYZ(const LabColor& lab, CIE_XYZ* xyz);
+
+void SkColorToLabColor(SkColor c, LabColor* lab);
+SkColor LabColorToSkColor(const LabColor& lab, SkAlpha alpha);
+
+// Determine if a given alpha value is nearly completely transparent.
+bool IsColorCloseToTransparent(SkAlpha alpha);
+
+// Determine if a color is near grey.
+bool IsColorCloseToGrey(int r, int g, int b);
+
+// Gets a color representing a bitmap. The definition of "representing" is the
+// average color in the bitmap. The color returned is modified to have the
+// specified alpha.
+SkColor GetAverageColorOfFavicon(SkBitmap* bitmap, SkAlpha alpha);
+
+// Builds a histogram based on the Y' of the Y'UV representation of
+// this image.
+void BuildLumaHistogram(SkBitmap* bitmap, int histogram[256]);
+
+// Create a color from a base color and a specific alpha value.
+SkColor SetColorAlpha(SkColor c, SkAlpha alpha);
+
+// Gets a Windows system color as a SkColor
+SkColor GetSysSkColor(int which);
+
+} // namespace color_utils
+
+#endif  // #ifndef APP_GFX_COLOR_UTILS_H_
diff --git a/app/gfx/text_elider.cc b/app/gfx/text_elider.cc
new file mode 100644
index 0000000..527f804
--- /dev/null
+++ b/app/gfx/text_elider.cc
@@ -0,0 +1,517 @@
+// Copyright (c) 2006-2008 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 "app/gfx/chrome_font.h"
+#include "app/gfx/text_elider.h"
+#include "base/file_path.h"
+#include "base/string_util.h"
+#include "base/sys_string_conversions.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/pref_service.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/escape.h"
+#include "net/base/net_util.h"
+#include "net/base/registry_controlled_domain.h"
+
+const wchar_t kEllipsis[] = L"\x2026";
+
+namespace gfx {
+
+// Appends the given part of the original URL to the output string formatted for
+// the user. The given parsed structure will be updated. The host name formatter
+// also takes the same accept languages component as ElideURL. |new_parsed| may
+// be null.
+static void AppendFormattedHost(const GURL& url,
+                                const std::wstring& languages,
+                                std::wstring* output,
+                                url_parse::Parsed* new_parsed);
+
+// Calls the unescaper for the substring |in_component| inside of the URL
+// |spec|. The decoded string will be appended to |output| and the resulting
+// range will be filled into |out_component|.
+static void AppendFormattedComponent(const std::string& spec,
+                                     const url_parse::Component& in_component,
+                                     std::wstring* output,
+                                     url_parse::Component* out_component);
+
+// This function takes a GURL object and elides it. It returns a string
+// which composed of parts from subdomain, domain, path, filename and query.
+// A "..." is added automatically at the end if the elided string is bigger
+// than the available pixel width. For available pixel width = 0, a formatted,
+// but un-elided, string is returned.
+//
+// TODO(pkasting): http://b/119635 This whole function gets
+// kerning/ligatures/etc. issues potentially wrong by assuming that the width of
+// a rendered string is always the sum of the widths of its substrings.  Also I
+// suspect it could be made simpler.
+std::wstring ElideUrl(const GURL& url,
+                      const ChromeFont& font,
+                      int available_pixel_width,
+                      const std::wstring& languages) {
+  // Get a formatted string and corresponding parsing of the url.
+  url_parse::Parsed parsed;
+  std::wstring url_string = GetCleanStringFromUrl(url, languages, &parsed,
+                                                  NULL);
+  if (available_pixel_width <= 0)
+    return url_string;
+
+  // If non-standard or not file type, return plain eliding.
+  if (!(url.SchemeIsFile() || url.IsStandard()))
+    return ElideText(url_string, font, available_pixel_width);
+
+  // Now start eliding url_string to fit within available pixel width.
+  // Fist pass - check to see whether entire url_string fits.
+  int pixel_width_url_string = font.GetStringWidth(url_string);
+  if (available_pixel_width >= pixel_width_url_string)
+    return url_string;
+
+  // Get the path substring, including query and reference.
+  size_t path_start_index = parsed.path.begin;
+  size_t path_len = parsed.path.len;
+  std::wstring url_path_query_etc = url_string.substr(path_start_index);
+  std::wstring url_path = url_string.substr(path_start_index, path_len);
+
+  // Return general elided text if url minus the query fits.
+  std::wstring url_minus_query = url_string.substr(0, path_start_index +
+      path_len);
+  if (available_pixel_width >= font.GetStringWidth(url_minus_query))
+    return ElideText(url_string, font, available_pixel_width);
+
+  // Get Host.
+  std::wstring url_host = UTF8ToWide(url.host());
+
+  // Get domain and registry information from the URL.
+  std::wstring url_domain = UTF8ToWide(
+      net::RegistryControlledDomainService::GetDomainAndRegistry(url));
+  if (url_domain.empty())
+    url_domain = url_host;
+
+  // Add port if required.
+  if (!url.port().empty()){
+    url_host += L":" + UTF8ToWide(url.port());
+    url_domain += L":" + UTF8ToWide(url.port());
+  }
+
+  // Get sub domain.
+  std::wstring url_subdomain;
+  size_t domain_start_index = url_host.find(url_domain);
+  if (domain_start_index > 0)
+    url_subdomain = url_host.substr(0, domain_start_index);
+  if ((url_subdomain == L"www." || url_subdomain.empty() ||
+      url.SchemeIsFile())) {
+    url_subdomain.clear();
+  }
+
+  // If this is a file type, the path is now defined as everything after ":".
+  // For example, "C:/aa/aa/bb", the path is "/aa/bb/cc". Interesting, the
+  // domain is now C: - this is a nice hack for eliding to work pleasantly.
+  if (url.SchemeIsFile()) {
+    // Split the path string using ":"
+    std::vector<std::wstring> file_path_split;
+    SplitString(url_path, L':', &file_path_split);
+    if (file_path_split.size() > 1) { // File is of type "file:///C:/.."
+      url_host.clear();
+      url_domain.clear();
+      url_subdomain.clear();
+
+      url_host = url_domain = file_path_split.at(0).substr(1) + L":";
+      url_path_query_etc = url_path = file_path_split.at(1);
+    }
+  }
+
+  // Second Pass - remove scheme - the rest fits.
+  int pixel_width_url_host = font.GetStringWidth(url_host);
+  int pixel_width_url_path = font.GetStringWidth(url_path_query_etc);
+  if (available_pixel_width >=
+      pixel_width_url_host + pixel_width_url_path)
+    return url_host + url_path_query_etc;
+
+  // Third Pass: Subdomain, domain and entire path fits.
+  int pixel_width_url_domain = font.GetStringWidth(url_domain);
+  int pixel_width_url_subdomain = font.GetStringWidth(url_subdomain);
+  if (available_pixel_width >=
+      pixel_width_url_subdomain + pixel_width_url_domain +
+      pixel_width_url_path)
+    return url_subdomain + url_domain + url_path_query_etc;
+
+  // Query element.
+  std::wstring url_query;
+  const int pixel_width_dots_trailer = font.GetStringWidth(kEllipsis);
+  if (parsed.query.is_nonempty()) {
+    url_query = std::wstring(L"?") + url_string.substr(parsed.query.begin);
+    if (available_pixel_width >= (pixel_width_url_subdomain +
+        pixel_width_url_domain + pixel_width_url_path -
+        font.GetStringWidth(url_query))) {
+      return ElideText(url_subdomain + url_domain + url_path_query_etc, font,
+                       available_pixel_width);
+    }
+  }
+
+  // Parse url_path using '/'.
+  std::vector<std::wstring> url_path_elements;
+  SplitString(url_path, L'/', &url_path_elements);
+
+  // Get filename - note that for a path ending with /
+  // such as www.google.com/intl/ads/, the file name is ads/.
+  int url_path_number_of_elements = static_cast<int> (url_path_elements.
+                                                      size());
+  std::wstring url_filename;
+  if ((url_path_elements.at(url_path_number_of_elements - 1)).length() > 0) {
+    url_filename = *(url_path_elements.end()-1);
+  } else if (url_path_number_of_elements > 1) {  // Path ends with a '/'.
+    url_filename = url_path_elements.at(url_path_number_of_elements - 2) +
+        L'/';
+    url_path_number_of_elements--;
+  }
+
+  const int kMaxNumberOfUrlPathElementsAllowed = 1024;
+  if (url_path_number_of_elements <= 1 ||
+      url_path_number_of_elements > kMaxNumberOfUrlPathElementsAllowed) {
+    // No path to elide, or too long of a path (could overflow in loop below)
+    // Just elide this as a text string.
+    return ElideText(url_subdomain + url_domain + url_path_query_etc, font,
+                     available_pixel_width);
+  }
+
+  // Start eliding the path and replacing elements by "../".
+  std::wstring an_ellipsis_and_a_slash(kEllipsis);
+  an_ellipsis_and_a_slash += L'/';
+  int pixel_width_url_filename = font.GetStringWidth(url_filename);
+  int pixel_width_dot_dot_slash = font.GetStringWidth(an_ellipsis_and_a_slash);
+  int pixel_width_slash = font.GetStringWidth(L"/");
+  int pixel_width_url_path_elements[kMaxNumberOfUrlPathElementsAllowed];
+  for (int i = 0; i < url_path_number_of_elements; ++i) {
+    pixel_width_url_path_elements[i] =
+       font.GetStringWidth(url_path_elements.at(i));
+  }
+
+  // Check with both subdomain and domain.
+  std::wstring elided_path;
+  int pixel_width_elided_path;
+  for (int i = url_path_number_of_elements - 1; i >= 1; --i) {
+    // Add the initial elements of the path.
+    elided_path.clear();
+    pixel_width_elided_path = 0;
+    for (int j = 0; j < i; ++j) {
+      elided_path += url_path_elements.at(j) + L'/';
+      pixel_width_elided_path += pixel_width_url_path_elements[j] +
+          pixel_width_slash;
+    }
+
+    // Add url_file_name.
+    if (i == (url_path_number_of_elements - 1)) {
+      elided_path += url_filename;
+      pixel_width_elided_path += pixel_width_url_filename;
+    } else {
+      elided_path += an_ellipsis_and_a_slash + url_filename;
+      pixel_width_elided_path += pixel_width_dot_dot_slash +
+          pixel_width_url_filename;
+    }
+
+    if (available_pixel_width >=
+        pixel_width_url_subdomain + pixel_width_url_domain +
+        pixel_width_elided_path) {
+      return ElideText(url_subdomain + url_domain + elided_path + url_query,
+                       font, available_pixel_width);
+    }
+  }
+
+  // Check with only domain.
+  // If a subdomain is present, add an ellipsis before domain.
+  // This is added only if the subdomain pixel width is larger than
+  // the pixel width of kEllipsis. Otherwise, subdomain remains,
+  // which means that this case has been resolved earlier.
+  std::wstring url_elided_domain = url_subdomain + url_domain;
+  int pixel_width_url_elided_domain = pixel_width_url_domain;
+  if (pixel_width_url_subdomain > pixel_width_dots_trailer) {
+    if (!url_subdomain.empty()) {
+      url_elided_domain = kEllipsis + url_domain;
+      pixel_width_url_elided_domain += pixel_width_dots_trailer;
+    } else {
+      url_elided_domain = url_domain;
+    }
+
+    for (int i = url_path_number_of_elements - 1; i >= 1; --i) {
+      // Add the initial elements of the path.
+      elided_path.clear();
+      pixel_width_elided_path = 0;
+      for (int j = 0; j < i; ++j) {
+        elided_path += url_path_elements.at(j) + L'/';
+        pixel_width_elided_path += pixel_width_url_path_elements[j] +
+            pixel_width_slash;
+      }
+
+      // Add url_file_name.
+      if (i == (url_path_number_of_elements - 1)) {
+        elided_path += url_filename;
+        pixel_width_elided_path += pixel_width_url_filename;
+      } else {
+        elided_path += an_ellipsis_and_a_slash + url_filename;
+        pixel_width_elided_path += pixel_width_dot_dot_slash +
+            pixel_width_url_filename;
+      }
+
+      if (available_pixel_width >=
+          pixel_width_url_elided_domain + pixel_width_elided_path) {
+        return ElideText(url_elided_domain + elided_path + url_query, font,
+                         available_pixel_width);
+      }
+    }
+  }
+
+  // Return elided domain/../filename anyway.
+  std::wstring final_elided_url_string(url_elided_domain);
+  if ((available_pixel_width - font.GetStringWidth(url_elided_domain)) >
+      pixel_width_dot_dot_slash + pixel_width_dots_trailer +
+      font.GetStringWidth(L"UV")) // A hack to prevent trailing "../...".
+    final_elided_url_string += elided_path;
+  else
+    final_elided_url_string += url_path;
+
+  return ElideText(final_elided_url_string, font, available_pixel_width);
+}
+
+std::wstring ElideFilename(const FilePath& filename,
+                           const ChromeFont& font,
+                           int available_pixel_width) {
+  int full_width = font.GetStringWidth(filename.ToWStringHack());
+  if (full_width <= available_pixel_width)
+    return filename.ToWStringHack();
+
+#if defined(OS_WIN)
+  std::wstring extension = filename.Extension();
+#elif defined(OS_POSIX)
+  std::wstring extension = base::SysNativeMBToWide(filename.Extension());
+#endif
+  std::wstring rootname =
+      filename.BaseName().RemoveExtension().ToWStringHack();
+
+  if (rootname.empty() || extension.empty())
+    return ElideText(filename.ToWStringHack(), font, available_pixel_width);
+
+  int ext_width = font.GetStringWidth(extension);
+  int root_width = font.GetStringWidth(rootname);
+
+  // We may have trimmed the path.
+  if (root_width + ext_width <= available_pixel_width)
+    return rootname + extension;
+
+  int available_root_width = available_pixel_width - ext_width;
+  return ElideText(rootname, font, available_root_width) + extension;
+}
+
+// This function adds an ellipsis at the end of the text if the text
+// does not fit the given pixel width.
+std::wstring ElideText(const std::wstring& text,
+                       const ChromeFont& font,
+                       int available_pixel_width){
+  if (text.empty())
+    return text;
+
+  int current_text_pixel_width = font.GetStringWidth(text);
+  if (current_text_pixel_width <= available_pixel_width)
+    return text;
+
+  if (font.GetStringWidth(kEllipsis) > available_pixel_width)
+    return std::wstring();
+
+  // Use binary search to compute the elided text.
+  size_t lo = 0;
+  size_t hi = text.length() - 1;
+  size_t guess = hi / 2;
+  while (lo < hi) {
+    // We check the length of the whole desired string at once to ensure we
+    // handle kerning/ligatures/etc. correctly.
+    std::wstring guess_str = text.substr(0, guess) + kEllipsis;
+    int guess_length = font.GetStringWidth(guess_str);
+    if (guess_length > available_pixel_width) {
+      if (hi == guess)
+        break;
+      hi = guess;
+    } else {
+      if (lo == guess)
+        break;
+      lo = guess;
+    }
+    guess = (lo + hi) / 2;
+  }
+
+  return text.substr(0, lo) + kEllipsis;
+}
+
+void AppendFormattedHost(const GURL& url,
+                         const std::wstring& languages,
+                         std::wstring* output,
+                         url_parse::Parsed* new_parsed) {
+  const url_parse::Component& host =
+      url.parsed_for_possibly_invalid_spec().host;
+
+  if (host.is_nonempty()) {
+    // Handle possible IDN in the host name.
+    if (new_parsed)
+      new_parsed->host.begin = static_cast<int>(output->length());
+
+    const std::string& spec = url.possibly_invalid_spec();
+    DCHECK(host.begin >= 0 &&
+           ((spec.length() == 0 && host.begin == 0) ||
+            host.begin < static_cast<int>(spec.length())));
+    net::IDNToUnicode(&spec[host.begin], host.len, languages, output);
+
+    if (new_parsed) {
+      new_parsed->host.len =
+          static_cast<int>(output->length()) - new_parsed->host.begin;
+    }
+  } else if (new_parsed) {
+    new_parsed->host.reset();
+  }
+}
+
+void AppendFormattedComponent(const std::string& spec,
+                              const url_parse::Component& in_component,
+                              std::wstring* output,
+                              url_parse::Component* out_component) {
+  if (in_component.is_nonempty()) {
+    out_component->begin = static_cast<int>(output->length());
+
+    output->append(UnescapeAndDecodeUTF8URLComponent(
+        spec.substr(in_component.begin, in_component.len),
+        UnescapeRule::NORMAL));
+
+    out_component->len =
+        static_cast<int>(output->length()) - out_component->begin;
+  } else {
+    out_component->reset();
+  }
+}
+
+std::wstring GetCleanStringFromUrl(const GURL& url,
+                                   const std::wstring& languages,
+                                   url_parse::Parsed* new_parsed,
+                                   size_t* prefix_end) {
+  url_parse::Parsed parsed_temp;
+  if (!new_parsed)
+    new_parsed = &parsed_temp;
+
+  std::wstring url_string;
+
+  // Check for empty URLs or 0 available text width.
+  if (url.is_empty()) {
+    if (prefix_end)
+      *prefix_end = 0;
+    return url_string;
+  }
+
+  // We handle both valid and invalid URLs (this will give us the spec
+  // regardless of validity).
+  const std::string& spec = url.possibly_invalid_spec();
+  const url_parse::Parsed& parsed = url.parsed_for_possibly_invalid_spec();
+
+  // Construct a new URL with the username and password fields removed. We
+  // don't want to display those to the user since they can be used for
+  // attacks, e.g. "http://google.com:search@evil.ru/"
+  //
+  // Copy everything before the host name we want (the scheme and the
+  // separators), minus the username start we computed above. These are ASCII.
+  int pre_end = parsed.CountCharactersBefore(
+      url_parse::Parsed::USERNAME, true);
+  for (int i = 0; i < pre_end; ++i)
+    url_string.push_back(spec[i]);
+  if (prefix_end)
+    *prefix_end = static_cast<size_t>(pre_end);
+  new_parsed->scheme = parsed.scheme;
+  new_parsed->username.reset();
+  new_parsed->password.reset();
+
+  AppendFormattedHost(url, languages, &url_string, new_parsed);
+
+  // Port.
+  if (parsed.port.is_nonempty()) {
+    url_string.push_back(':');
+    for (int i = parsed.port.begin; i < parsed.port.end(); ++i)
+      url_string.push_back(spec[i]);
+  }
+
+  // Path and query both get the same general unescape & convert treatment.
+  AppendFormattedComponent(spec, parsed.path, &url_string, &new_parsed->path);
+  if (parsed.query.is_valid())
+    url_string.push_back('?');
+  AppendFormattedComponent(spec, parsed.query, &url_string, &new_parsed->query);
+
+  // Reference is stored in valid, unescaped UTF-8, so we can just convert.
+  if (parsed.ref.is_valid()) {
+    url_string.push_back('#');
+    if (parsed.ref.len > 0)
+      url_string.append(UTF8ToWide(std::string(&spec[parsed.ref.begin],
+                                               parsed.ref.len)));
+  }
+
+  return url_string;
+}
+
+SortedDisplayURL::SortedDisplayURL(const GURL& url,
+                                   const std::wstring& languages) {
+  std::wstring host;
+  AppendFormattedHost(url, languages, &host, NULL);
+  sort_host_ = WideToUTF16Hack(host);
+  string16 host_minus_www = WideToUTF16Hack(net::StripWWW(host));
+  url_parse::Parsed parsed;
+  display_url_ = WideToUTF16Hack(GetCleanStringFromUrl(url, languages,
+      &parsed, &prefix_end_));
+  if (sort_host_.length() > host_minus_www.length()) {
+    prefix_end_ += sort_host_.length() - host_minus_www.length();
+    sort_host_.swap(host_minus_www);
+  }
+}
+
+int SortedDisplayURL::Compare(const SortedDisplayURL& other,
+                              Collator* collator) const {
+  // Compare on hosts first. The host won't contain 'www.'.
+  UErrorCode compare_status = U_ZERO_ERROR;
+  UCollationResult host_compare_result = collator->compare(
+      static_cast<const UChar*>(sort_host_.c_str()),
+      static_cast<int>(sort_host_.length()),
+      static_cast<const UChar*>(other.sort_host_.c_str()),
+      static_cast<int>(other.sort_host_.length()),
+      compare_status);
+  DCHECK(U_SUCCESS(compare_status));
+  if (host_compare_result != 0)
+    return host_compare_result;
+
+  // Hosts match, compare on the portion of the url after the host.
+  string16 path = this->AfterHost();
+  string16 o_path = other.AfterHost();
+  compare_status = U_ZERO_ERROR;
+  UCollationResult path_compare_result = collator->compare(
+      static_cast<const UChar*>(path.c_str()),
+      static_cast<int>(path.length()),
+      static_cast<const UChar*>(o_path.c_str()),
+      static_cast<int>(o_path.length()),
+      compare_status);
+  DCHECK(U_SUCCESS(compare_status));
+  if (path_compare_result != 0)
+    return path_compare_result;
+
+  // Hosts and paths match, compare on the complete url. This'll push the www.
+  // ones to the end.
+  compare_status = U_ZERO_ERROR;
+  UCollationResult display_url_compare_result = collator->compare(
+      static_cast<const UChar*>(display_url_.c_str()),
+      static_cast<int>(display_url_.length()),
+      static_cast<const UChar*>(other.display_url_.c_str()),
+      static_cast<int>(other.display_url_.length()),
+      compare_status);
+  DCHECK(U_SUCCESS(compare_status));
+  return display_url_compare_result;
+}
+
+string16 SortedDisplayURL::AfterHost() const {
+  size_t slash_index = display_url_.find(sort_host_, prefix_end_);
+  if (slash_index == string16::npos) {
+    NOTREACHED();
+    return string16();
+  }
+  return display_url_.substr(slash_index + sort_host_.length());
+}
+
+} // namespace gfx.
diff --git a/app/gfx/text_elider.h b/app/gfx/text_elider.h
new file mode 100644
index 0000000..61bfada
--- /dev/null
+++ b/app/gfx/text_elider.h
@@ -0,0 +1,99 @@
+// Copyright (c) 2006-2008 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.
+
+#ifndef CHROME_COMMON_GFX_TEXT_ELIDER_H_
+#define CHROME_COMMON_GFX_TEXT_ELIDER_H_
+
+#include <unicode/coll.h>
+#include <unicode/uchar.h>
+
+#include "app/gfx/chrome_font.h"
+#include "base/basictypes.h"
+#include "base/string16.h"
+
+class FilePath;
+class GURL;
+
+namespace url_parse {
+struct Parsed;
+}
+
+// TODO(port): this file should deal in string16s rather than wstrings.
+namespace gfx {
+
+// A function to get URL string from a GURL that will be suitable for display
+// to the user. The parsing of the URL may change because various parts of the
+// string will change lengths. The new parsing will be placed in the given out
+// parameter. |prefix_end| is set to the end of the prefix (spec and separator
+// characters before host).
+// |languages|, |new_parsed|, and |prefix_end| may all be empty or NULL.
+std::wstring GetCleanStringFromUrl(const GURL& url,
+                                   const std::wstring& languages,
+                                   url_parse::Parsed* new_parsed,
+                                   size_t* prefix_end);
+
+// This function takes a GURL object and elides it. It returns a string
+// which composed of parts from subdomain, domain, path, filename and query.
+// A "..." is added automatically at the end if the elided string is bigger
+// than the available pixel width. For available pixel width = 0, empty
+// string is returned. |languages| is a comma separted list of ISO 639
+// language codes and is used to determine what characters are understood
+// by a user. It should come from |prefs::kAcceptLanguages|.
+//
+// Note: in RTL locales, if the URL returned by this function is going to be
+// displayed in the UI, then it is likely that the string needs to be marked
+// as an LTR string (using l10n_util::WrapStringWithLTRFormatting()) so that it
+// is displayed properly in an RTL context. Please refer to
+// http://crbug.com/6487 for more information.
+std::wstring ElideUrl(const GURL& url,
+                      const ChromeFont& font,
+                      int available_pixel_width,
+                      const std::wstring& languages);
+
+std::wstring ElideText(const std::wstring& text,
+                       const ChromeFont& font,
+                       int available_pixel_width);
+
+// Elide a filename to fit a given pixel width, with an emphasis on not hiding
+// the extension unless we have to. If filename contains a path, the path will
+// be removed if filename doesn't fit into available_pixel_width.
+std::wstring ElideFilename(const FilePath& filename,
+                           const ChromeFont& font,
+                           int available_pixel_width);
+
+// SortedDisplayURL maintains a string from a URL suitable for display to the
+// use. SortedDisplayURL also provides a function used for comparing two
+// SortedDisplayURLs for use in visually ordering the SortedDisplayURLs.
+//
+// SortedDisplayURL is relatively cheap and supports value semantics.
+class SortedDisplayURL {
+ public:
+  SortedDisplayURL(const GURL& url, const std::wstring& languages);
+  SortedDisplayURL() {}
+
+  // Compares this SortedDisplayURL to |url| using |collator|. Returns a value
+  // < 0, = 1 or > 0 as to whether this url is less then, equal to or greater
+  // than the supplied url.
+  int Compare(const SortedDisplayURL& other, Collator* collator) const;
+
+  // Returns the display string for the URL.
+  const string16& display_url() const { return display_url_; }
+
+ private:
+  // Returns everything after the host. This is used by Compare if the hosts
+  // match.
+  string16 AfterHost() const;
+
+  // Host name minus 'www.'. Used by Compare.
+  string16 sort_host_;
+
+  // End of the prefix (spec and separator) in display_url_.
+  size_t prefix_end_;
+
+  string16 display_url_;
+};
+
+} // namespace gfx.
+
+#endif  // CHROME_COMMON_GFX_TEXT_ELIDER_H_
diff --git a/app/gfx/text_elider_unittest.cc b/app/gfx/text_elider_unittest.cc
new file mode 100644
index 0000000..0f17f9f
--- /dev/null
+++ b/app/gfx/text_elider_unittest.cc
@@ -0,0 +1,267 @@
+// Copyright (c) 2006-2008 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 "app/gfx/chrome_font.h"
+#include "app/gfx/text_elider.h"
+#include "base/file_path.h"
+#include "base/string_util.h"
+#include "googleurl/src/gurl.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using namespace gfx;
+
+namespace {
+
+const wchar_t kEllipsis[] = L"\x2026";
+
+struct Testcase {
+  const std::string input;
+  const std::wstring output;
+};
+
+struct FileTestcase {
+  const FilePath::StringType input;
+  const std::wstring output;
+};
+
+struct WideTestcase {
+  const std::wstring input;
+  const std::wstring output;
+};
+
+struct TestData {
+  const std::string a;
+  const std::string b;
+  const int compare_result;
+};
+
+void RunTest(Testcase* testcases, size_t num_testcases) {
+  static const ChromeFont font;
+  for (size_t i = 0; i < num_testcases; ++i) {
+    const GURL url(testcases[i].input);
+    // Should we test with non-empty language list?
+    // That's kinda redundant with net_util_unittests.
+    EXPECT_EQ(testcases[i].output,
+              ElideUrl(url, font, font.GetStringWidth(testcases[i].output),
+                       std::wstring()));
+  }
+}
+
+}  // namespace
+
+// Test eliding of commonplace URLs.
+TEST(TextEliderTest, TestGeneralEliding) {
+  const std::wstring kEllipsisStr(kEllipsis);
+  Testcase testcases[] = {
+    {"http://www.google.com/intl/en/ads/",
+     L"http://www.google.com/intl/en/ads/"},
+    {"http://www.google.com/intl/en/ads/", L"www.google.com/intl/en/ads/"},
+// TODO(port): make this test case work on mac.
+#if !defined(OS_MACOSX)
+    {"http://www.google.com/intl/en/ads/",
+     L"google.com/intl/" + kEllipsisStr + L"/ads/"},
+#endif
+    {"http://www.google.com/intl/en/ads/",
+     L"google.com/" + kEllipsisStr + L"/ads/"},
+    {"http://www.google.com/intl/en/ads/", L"google.com/" + kEllipsisStr},
+    {"http://www.google.com/intl/en/ads/", L"goog" + kEllipsisStr},
+    {"https://subdomain.foo.com/bar/filename.html",
+     L"subdomain.foo.com/bar/filename.html"},
+    {"https://subdomain.foo.com/bar/filename.html",
+     L"subdomain.foo.com/" + kEllipsisStr + L"/filename.html"},
+    {"http://subdomain.foo.com/bar/filename.html",
+     kEllipsisStr + L"foo.com/" + kEllipsisStr + L"/filename.html"},
+    {"http://www.google.com/intl/en/ads/?aLongQueryWhichIsNotRequired",
+     L"http://www.google.com/intl/en/ads/?aLongQ" + kEllipsisStr},
+  };
+
+  RunTest(testcases, arraysize(testcases));
+}
+
+// Test eliding of empty strings, URLs with ports, passwords, queries, etc.
+TEST(TextEliderTest, TestMoreEliding) {
+  const std::wstring kEllipsisStr(kEllipsis);
+  Testcase testcases[] = {
+    {"http://www.google.com/foo?bar", L"http://www.google.com/foo?bar"},
+    {"http://xyz.google.com/foo?bar", L"xyz.google.com/foo?" + kEllipsisStr},
+    {"http://xyz.google.com/foo?bar", L"xyz.google.com/foo" + kEllipsisStr},
+    {"http://xyz.google.com/foo?bar", L"xyz.google.com/fo" + kEllipsisStr},
+    {"http://a.b.com/pathname/c?d", L"a.b.com/" + kEllipsisStr + L"/c?d"},
+    {"", L""},
+    {"http://foo.bar..example.com...hello/test/filename.html",
+     L"foo.bar..example.com...hello/" + kEllipsisStr + L"/filename.html"},
+    {"http://foo.bar../", L"http://foo.bar../"},
+    {"http://xn--1lq90i.cn/foo", L"http://\x5317\x4eac.cn/foo"},
+    {"http://me:mypass@secrethost.com:99/foo?bar#baz",
+     L"http://secrethost.com:99/foo?bar#baz"},
+    {"http://me:mypass@ss%xxfdsf.com/foo", L"http://ss%25xxfdsf.com/foo"},
+    {"mailto:elgoato@elgoato.com", L"mailto:elgoato@elgoato.com"},
+    {"javascript:click(0)", L"javascript:click(0)"},
+    {"https://chess.eecs.berkeley.edu:4430/login/arbitfilename",
+     L"chess.eecs.berkeley.edu:4430/login/arbitfilename"},
+    {"https://chess.eecs.berkeley.edu:4430/login/arbitfilename",
+     kEllipsisStr + L"berkeley.edu:4430/" + kEllipsisStr + L"/arbitfilename"},
+
+    // Unescaping.
+    {"http://www/%E4%BD%A0%E5%A5%BD?q=%E4%BD%A0%E5%A5%BD#\xe4\xbd\xa0",
+     L"http://www/\x4f60\x597d?q=\x4f60\x597d#\x4f60"},
+
+    // Invalid unescaping for path. The ref will always be valid UTF-8. We don't
+    // bother to do too many edge cases, since these are handled by the escaper
+    // unittest.
+    {"http://www/%E4%A0%E5%A5%BD?q=%E4%BD%A0%E5%A5%BD#\xe4\xbd\xa0",
+     L"http://www/%E4%A0%E5%A5%BD?q=\x4f60\x597d#\x4f60"},
+  };
+
+  RunTest(testcases, arraysize(testcases));
+}
+
+// Test eliding of file: URLs.
+TEST(TextEliderTest, TestFileURLEliding) {
+  const std::wstring kEllipsisStr(kEllipsis);
+  Testcase testcases[] = {
+    {"file:///C:/path1/path2/path3/filename",
+     L"file:///C:/path1/path2/path3/filename"},
+    {"file:///C:/path1/path2/path3/filename",
+     L"C:/path1/path2/path3/filename"},
+// GURL parses "file:///C:path" differently on windows than it does on posix.
+#if defined(OS_WIN)
+    {"file:///C:path1/path2/path3/filename",
+     L"C:/path1/path2/" + kEllipsisStr + L"/filename"},
+    {"file:///C:path1/path2/path3/filename",
+     L"C:/path1/" + kEllipsisStr + L"/filename"},
+    {"file:///C:path1/path2/path3/filename",
+     L"C:/" + kEllipsisStr + L"/filename"},
+#endif
+    {"file://filer/foo/bar/file", L"filer/foo/bar/file"},
+    {"file://filer/foo/bar/file", L"filer/foo/" + kEllipsisStr + L"/file"},
+    {"file://filer/foo/bar/file", L"filer/" + kEllipsisStr + L"/file"},
+  };
+
+  RunTest(testcases, arraysize(testcases));
+}
+
+TEST(TextEliderTest, TestFilenameEliding) {
+  const std::wstring kEllipsisStr(kEllipsis);
+  const FilePath::StringType kPathSeparator =
+      FilePath::StringType().append(1, FilePath::kSeparators[0]);
+
+  FileTestcase testcases[] = {
+    {FILE_PATH_LITERAL(""), L""},
+    {FILE_PATH_LITERAL("."), L"."},
+    {FILE_PATH_LITERAL("filename.exe"), L"filename.exe"},
+    {FILE_PATH_LITERAL(".longext"), L".longext"},
+    {FILE_PATH_LITERAL("pie"), L"pie"},
+    {FILE_PATH_LITERAL("c:") + kPathSeparator + FILE_PATH_LITERAL("path") +
+      kPathSeparator + FILE_PATH_LITERAL("filename.pie"),
+      L"filename.pie"},
+    {FILE_PATH_LITERAL("c:") + kPathSeparator + FILE_PATH_LITERAL("path") +
+      kPathSeparator + FILE_PATH_LITERAL("longfilename.pie"),
+      L"long" + kEllipsisStr + L".pie"},
+    {FILE_PATH_LITERAL("http://path.com/filename.pie"), L"filename.pie"},
+    {FILE_PATH_LITERAL("http://path.com/longfilename.pie"),
+      L"long" + kEllipsisStr + L".pie"},
+    {FILE_PATH_LITERAL("piesmashingtacularpants"), L"pie" + kEllipsisStr},
+    {FILE_PATH_LITERAL(".piesmashingtacularpants"), L".pie" + kEllipsisStr},
+    {FILE_PATH_LITERAL("cheese."), L"cheese."},
+    {FILE_PATH_LITERAL("file name.longext"),
+      L"file" + kEllipsisStr + L".longext"},
+    {FILE_PATH_LITERAL("fil ename.longext"),
+      L"fil " + kEllipsisStr + L".longext"},
+    {FILE_PATH_LITERAL("filename.longext"),
+      L"file" + kEllipsisStr + L".longext"},
+    {FILE_PATH_LITERAL("filename.middleext.longext"),
+      L"filename.mid" + kEllipsisStr + L".longext"}
+  };
+
+  static const ChromeFont font;
+  for (size_t i = 0; i < arraysize(testcases); ++i) {
+    FilePath filepath(testcases[i].input);
+    EXPECT_EQ(testcases[i].output, ElideFilename(filepath,
+        font,
+        font.GetStringWidth(testcases[i].output)));
+  }
+}
+
+TEST(TextEliderTest, ElideTextLongStrings) {
+  const std::wstring kEllipsisStr(kEllipsis);
+  std::wstring data_scheme(L"data:text/plain,");
+
+  std::wstring ten_a(10, L'a');
+  std::wstring hundred_a(100, L'a');
+  std::wstring thousand_a(1000, L'a');
+  std::wstring ten_thousand_a(10000, L'a');
+  std::wstring hundred_thousand_a(100000, L'a');
+  std::wstring million_a(1000000, L'a');
+
+  WideTestcase testcases[] = {
+     {data_scheme + ten_a,
+      data_scheme + ten_a},
+     {data_scheme + hundred_a,
+      data_scheme + hundred_a},
+     {data_scheme + thousand_a,
+      data_scheme + std::wstring(156, L'a') + kEllipsisStr},
+     {data_scheme + ten_thousand_a,
+      data_scheme + std::wstring(156, L'a') + kEllipsisStr},
+     {data_scheme + hundred_thousand_a,
+      data_scheme + std::wstring(156, L'a') + kEllipsisStr},
+     {data_scheme + million_a,
+      data_scheme + std::wstring(156, L'a') + kEllipsisStr},
+  };
+
+  const ChromeFont font;
+  int ellipsis_width = font.GetStringWidth(kEllipsisStr);
+  for (size_t i = 0; i < arraysize(testcases); ++i) {
+    // Compare sizes rather than actual contents because if the test fails,
+    // output is rather long.
+    EXPECT_EQ(testcases[i].output.size(),
+              ElideText(testcases[i].input, font,
+                        font.GetStringWidth(testcases[i].output)).size());
+    EXPECT_EQ(kEllipsisStr,
+              ElideText(testcases[i].input, font, ellipsis_width));
+  }
+}
+
+// Verifies display_url is set correctly.
+TEST(TextEliderTest, SortedDisplayURL) {
+  gfx::SortedDisplayURL d_url(GURL("http://www.google.com/"), std::wstring());
+  EXPECT_EQ("http://www.google.com/", UTF16ToASCII(d_url.display_url()));
+}
+
+// Verifies DisplayURL::Compare works correctly.
+TEST(TextEliderTest, SortedDisplayURLCompare) {
+  UErrorCode create_status = U_ZERO_ERROR;
+  scoped_ptr<Collator> collator(Collator::createInstance(create_status));
+  if (!U_SUCCESS(create_status))
+    return;
+
+  TestData tests[] = {
+    // IDN comparison. Hosts equal, so compares on path.
+    { "http://xn--1lq90i.cn/a", "http://xn--1lq90i.cn/b", -1},
+
+    // Because the host and after host match, this compares the full url.
+    { "http://www.x/b", "http://x/b", -1 },
+
+    // Because the host and after host match, this compares the full url.
+    { "http://www.a:1/b", "http://a:1/b", 1 },
+
+    // The hosts match, so these end up comparing on the after host portion.
+    { "http://www.x:0/b", "http://x:1/b", -1 },
+    { "http://www.x/a", "http://x/b", -1 },
+    { "http://x/b", "http://www.x/a", 1 },
+
+    // Trivial Equality.
+    { "http://a/", "http://a/", 0 },
+
+    // Compares just hosts.
+    { "http://www.a/", "http://b/", -1 },
+  };
+
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    gfx::SortedDisplayURL url1(GURL(tests[i].a), std::wstring());
+    gfx::SortedDisplayURL url2(GURL(tests[i].b), std::wstring());
+    EXPECT_EQ(tests[i].compare_result, url1.Compare(url2, collator.get()));
+    EXPECT_EQ(-tests[i].compare_result, url2.Compare(url1, collator.get()));
+  }
+}