Try2 of issue 18772. (move jpeg_codec* to base/gfx)

Review URL: http://codereview.chromium.org/18838

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

10 files changed, 837 insertions, 25 deletions

diff --git a/base/base.sln b/base/base.sln
index 0eedd1a..aae3c5b 100644
--- a/base/base.sln
+++ b/base/base.sln
@@ -16,12 +16,13 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "base_unittests", "build\bas
 	EndProjectSection
 	ProjectSection(ProjectDependencies) = postProject
 		{1832A374-8A74-4F9E-B536-69A699B3E165} = {1832A374-8A74-4F9E-B536-69A699B3E165}
-		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C} = {8423AF0D-4B88-4EBF-94E1-E4D00D00E21C}
-		{8C27D792-2648-4F5E-9ED0-374276327308} = {8C27D792-2648-4F5E-9ED0-374276327308}
-		{A508ADD3-CECE-4E0F-8448-2F5E454DF551} = {A508ADD3-CECE-4E0F-8448-2F5E454DF551}
-		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B} = {BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}
-		{C564F145-9172-42C3-BFCB-6014CA97DBCD} = {C564F145-9172-42C3-BFCB-6014CA97DBCD}
+		{238CE175-76CE-4A25-A676-69D115885601} = {238CE175-76CE-4A25-A676-69D115885601}
 		{CD9CA56E-4E94-444C-87D4-58CA1E6F300D} = {CD9CA56E-4E94-444C-87D4-58CA1E6F300D}
+		{C564F145-9172-42C3-BFCB-6014CA97DBCD} = {C564F145-9172-42C3-BFCB-6014CA97DBCD}
+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B} = {BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}
+		{A508ADD3-CECE-4E0F-8448-2F5E454DF551} = {A508ADD3-CECE-4E0F-8448-2F5E454DF551}
+		{8C27D792-2648-4F5E-9ED0-374276327308} = {8C27D792-2648-4F5E-9ED0-374276327308}
+		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C} = {8423AF0D-4B88-4EBF-94E1-E4D00D00E21C}
 	EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "debug_message", "build\debug_message.vcproj", "{0E5474AC-5996-4B13-87C0-4AE931EE0815}"
@@ -81,16 +82,18 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest", "..\testing\gtest.v
 		Release.AspNetCompiler.Debug = "False"
 	EndProjectSection
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libjpeg", "..\third_party\libjpeg\libjpeg.vcproj", "{238CE175-76CE-4A25-A676-69D115885601}"
+	ProjectSection(WebsiteProperties) = preProject
+		Debug.AspNetCompiler.Debug = "True"
+		Release.AspNetCompiler.Debug = "False"
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
 		Release|Win32 = Release|Win32
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{0E5474AC-5996-4B13-87C0-4AE931EE0815}.Debug|Win32.ActiveCfg = Debug|Win32
-		{0E5474AC-5996-4B13-87C0-4AE931EE0815}.Debug|Win32.Build.0 = Debug|Win32
-		{0E5474AC-5996-4B13-87C0-4AE931EE0815}.Release|Win32.ActiveCfg = Release|Win32
-		{0E5474AC-5996-4B13-87C0-4AE931EE0815}.Release|Win32.Build.0 = Release|Win32
 		{1832A374-8A74-4F9E-B536-69A699B3E165}.Debug|Win32.ActiveCfg = Debug|Win32
 		{1832A374-8A74-4F9E-B536-69A699B3E165}.Debug|Win32.Build.0 = Debug|Win32
 		{1832A374-8A74-4F9E-B536-69A699B3E165}.Release|Win32.ActiveCfg = Release|Win32
@@ -99,10 +102,10 @@ Global
 		{27A30967-4BBA-48D1-8522-CDE95F7B1CEC}.Debug|Win32.Build.0 = Debug|Win32
 		{27A30967-4BBA-48D1-8522-CDE95F7B1CEC}.Release|Win32.ActiveCfg = Release|Win32
 		{27A30967-4BBA-48D1-8522-CDE95F7B1CEC}.Release|Win32.Build.0 = Release|Win32
-		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C}.Debug|Win32.ActiveCfg = Debug|Win32
-		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C}.Debug|Win32.Build.0 = Debug|Win32
-		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C}.Release|Win32.ActiveCfg = Release|Win32
-		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C}.Release|Win32.Build.0 = Release|Win32
+		{0E5474AC-5996-4B13-87C0-4AE931EE0815}.Debug|Win32.ActiveCfg = Debug|Win32
+		{0E5474AC-5996-4B13-87C0-4AE931EE0815}.Debug|Win32.Build.0 = Debug|Win32
+		{0E5474AC-5996-4B13-87C0-4AE931EE0815}.Release|Win32.ActiveCfg = Release|Win32
+		{0E5474AC-5996-4B13-87C0-4AE931EE0815}.Release|Win32.Build.0 = Release|Win32
 		{8C27D792-2648-4F5E-9ED0-374276327308}.Debug|Win32.ActiveCfg = Debug|Win32
 		{8C27D792-2648-4F5E-9ED0-374276327308}.Debug|Win32.Build.0 = Debug|Win32
 		{8C27D792-2648-4F5E-9ED0-374276327308}.Release|Win32.ActiveCfg = Release|Win32
@@ -115,28 +118,37 @@ Global
 		{A508ADD3-CECE-4E0F-8448-2F5E454DF551}.Debug|Win32.Build.0 = Debug|Win32
 		{A508ADD3-CECE-4E0F-8448-2F5E454DF551}.Release|Win32.ActiveCfg = Release|Win32
 		{A508ADD3-CECE-4E0F-8448-2F5E454DF551}.Release|Win32.Build.0 = Release|Win32
-		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Debug|Win32.ActiveCfg = Debug|Win32
-		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Debug|Win32.Build.0 = Debug|Win32
-		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Release|Win32.ActiveCfg = Release|Win32
-		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Release|Win32.Build.0 = Release|Win32
-		{C564F145-9172-42C3-BFCB-6014CA97DBCD}.Debug|Win32.ActiveCfg = Debug|Win32
-		{C564F145-9172-42C3-BFCB-6014CA97DBCD}.Debug|Win32.Build.0 = Debug|Win32
-		{C564F145-9172-42C3-BFCB-6014CA97DBCD}.Release|Win32.ActiveCfg = Release|Win32
-		{C564F145-9172-42C3-BFCB-6014CA97DBCD}.Release|Win32.Build.0 = Release|Win32
 		{CD9CA56E-4E94-444C-87D4-58CA1E6F300D}.Debug|Win32.ActiveCfg = Debug|Win32
 		{CD9CA56E-4E94-444C-87D4-58CA1E6F300D}.Debug|Win32.Build.0 = Debug|Win32
 		{CD9CA56E-4E94-444C-87D4-58CA1E6F300D}.Release|Win32.ActiveCfg = Release|Win32
 		{CD9CA56E-4E94-444C-87D4-58CA1E6F300D}.Release|Win32.Build.0 = Release|Win32
+		{C564F145-9172-42C3-BFCB-6014CA97DBCD}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C564F145-9172-42C3-BFCB-6014CA97DBCD}.Debug|Win32.Build.0 = Debug|Win32
+		{C564F145-9172-42C3-BFCB-6014CA97DBCD}.Release|Win32.ActiveCfg = Release|Win32
+		{C564F145-9172-42C3-BFCB-6014CA97DBCD}.Release|Win32.Build.0 = Release|Win32
+		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C}.Debug|Win32.ActiveCfg = Debug|Win32
+		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C}.Debug|Win32.Build.0 = Debug|Win32
+		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C}.Release|Win32.ActiveCfg = Release|Win32
+		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C}.Release|Win32.Build.0 = Release|Win32
+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Debug|Win32.ActiveCfg = Debug|Win32
+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Debug|Win32.Build.0 = Debug|Win32
+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Release|Win32.ActiveCfg = Release|Win32
+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Release|Win32.Build.0 = Release|Win32
+		{238CE175-76CE-4A25-A676-69D115885601}.Debug|Win32.ActiveCfg = Debug|Win32
+		{238CE175-76CE-4A25-A676-69D115885601}.Debug|Win32.Build.0 = Debug|Win32
+		{238CE175-76CE-4A25-A676-69D115885601}.Release|Win32.ActiveCfg = Release|Win32
+		{238CE175-76CE-4A25-A676-69D115885601}.Release|Win32.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
-		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C} = {F216062D-F9C4-4883-A52C-2BE9ECADEEA0}
 		{8C27D792-2648-4F5E-9ED0-374276327308} = {F216062D-F9C4-4883-A52C-2BE9ECADEEA0}
 		{A0D94973-D355-47A5-A1E2-3456F321F010} = {F216062D-F9C4-4883-A52C-2BE9ECADEEA0}
-		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B} = {F216062D-F9C4-4883-A52C-2BE9ECADEEA0}
-		{C564F145-9172-42C3-BFCB-6014CA97DBCD} = {F216062D-F9C4-4883-A52C-2BE9ECADEEA0}
 		{CD9CA56E-4E94-444C-87D4-58CA1E6F300D} = {F216062D-F9C4-4883-A52C-2BE9ECADEEA0}
+		{C564F145-9172-42C3-BFCB-6014CA97DBCD} = {F216062D-F9C4-4883-A52C-2BE9ECADEEA0}
+		{8423AF0D-4B88-4EBF-94E1-E4D00D00E21C} = {F216062D-F9C4-4883-A52C-2BE9ECADEEA0}
+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B} = {F216062D-F9C4-4883-A52C-2BE9ECADEEA0}
+		{238CE175-76CE-4A25-A676-69D115885601} = {F216062D-F9C4-4883-A52C-2BE9ECADEEA0}
 	EndGlobalSection
 EndGlobal
diff --git a/base/base.xcodeproj/project.pbxproj b/base/base.xcodeproj/project.pbxproj
index e5ef83a..e347a84 100644
--- a/base/base.xcodeproj/project.pbxproj
+++ b/base/base.xcodeproj/project.pbxproj
@@ -37,6 +37,9 @@
 /* Begin PBXBuildFile section */
 		141593B80EA63EBE00E32418 /* thread_collision_warner_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 146C6A6E0EA63D970029E7B6 /* thread_collision_warner_unittest.cc */; };
 		146C6A6B0EA63D4F0029E7B6 /* thread_collision_warner.cc in Sources */ = {isa = PBXBuildFile; fileRef = 146C6A620EA63CAE0029E7B6 /* thread_collision_warner.cc */; };
+		32AC71B80F2E5321002BDDC8 /* jpeg_codec_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 32AC71B50F2E52FC002BDDC8 /* jpeg_codec_unittest.cc */; };
+		32AC71BF0F2E5421002BDDC8 /* jpeg_codec.cc in Sources */ = {isa = PBXBuildFile; fileRef = 32AC71B60F2E530F002BDDC8 /* jpeg_codec.cc */; };
+		32AC72300F2E64F7002BDDC8 /* libjpeg.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 32AC718E0F2E4F62002BDDC8 /* libjpeg.a */; };
 		4D11B59A0E91730200EF7617 /* rand_util.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D11B5940E9172F800EF7617 /* rand_util.cc */; };
 		4D11B59B0E91730200EF7617 /* rand_util_posix.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D11B5960E9172F800EF7617 /* rand_util_posix.cc */; };
 		4D11B59C0E91730500EF7617 /* rand_util_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D11B5970E9172F800EF7617 /* rand_util_unittest.cc */; };
@@ -194,6 +197,20 @@
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
+		3236FBC80F2E9FC8005DC6EF /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 32AC71890F2E4F62002BDDC8 /* libjpeg.xcodeproj */;
+			proxyType = 1;
+			remoteGlobalIDString = D2AAC045055464E500DB518D /* libjpeg */;
+			remoteInfo = libjpeg;
+		};
+		32AC718D0F2E4F62002BDDC8 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 32AC71890F2E4F62002BDDC8 /* libjpeg.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = D2AAC046055464E500DB518D;
+			remoteInfo = libjpeg;
+		};
 		7B165D2F0E55081000185273 /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = E45A2C680E47AEFF00DB1196 /* gtest.xcodeproj */;
@@ -382,6 +399,10 @@
 		146C6A610EA63C9F0029E7B6 /* thread_collision_warner.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = thread_collision_warner.h; sourceTree = "<group>"; };
 		146C6A620EA63CAE0029E7B6 /* thread_collision_warner.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = thread_collision_warner.cc; sourceTree = "<group>"; };
 		146C6A6E0EA63D970029E7B6 /* thread_collision_warner_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = thread_collision_warner_unittest.cc; sourceTree = "<group>"; };
+		32AC71890F2E4F62002BDDC8 /* libjpeg.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = libjpeg.xcodeproj; path = third_party/libjpeg/libjpeg.xcodeproj; sourceTree = "<group>"; };
+		32AC71B50F2E52FC002BDDC8 /* jpeg_codec_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = jpeg_codec_unittest.cc; sourceTree = "<group>"; };
+		32AC71B60F2E530F002BDDC8 /* jpeg_codec.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = jpeg_codec.cc; sourceTree = "<group>"; };
+		32AC71B70F2E530F002BDDC8 /* jpeg_codec.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = jpeg_codec.h; sourceTree = "<group>"; };
 		38246046390EAED65BB7C380 /* waitable_event_watcher_posix.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = waitable_event_watcher_posix.cc; sourceTree = "<group>"; };
 		4D11B5940E9172F800EF7617 /* rand_util.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = rand_util.cc; sourceTree = "<group>"; };
 		4D11B5950E9172F800EF7617 /* rand_util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rand_util.h; sourceTree = "<group>"; };
@@ -704,6 +725,7 @@
 				7B836E180E55CE5B00F6AD31 /* libicudata.a in Frameworks */,
 				7B836ADE0E55097000F6AD31 /* libicui18n.a in Frameworks */,
 				7B836ADD0E55097000F6AD31 /* libicuuc.a in Frameworks */,
+				32AC72300F2E64F7002BDDC8 /* libjpeg.a in Frameworks */,
 				7B85062A0E5B556900730B43 /* libpng.a in Frameworks */,
 				7B4DF5350E5B6A66004D7619 /* libskia.a in Frameworks */,
 				7B85062F0E5B559A00730B43 /* libzlib.a in Frameworks */,
@@ -713,6 +735,14 @@
 /* End PBXFrameworksBuildPhase section */
 
 /* Begin PBXGroup section */
+		32AC718A0F2E4F62002BDDC8 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				32AC718E0F2E4F62002BDDC8 /* libjpeg.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
 		7B165D2C0E55081000185273 /* Products */ = {
 			isa = PBXGroup;
 			children = (
@@ -773,6 +803,7 @@
 				E45A2C680E47AEFF00DB1196 /* gtest.xcodeproj */,
 				E4562AF30E27E428005E4685 /* icu.xcodeproj */,
 				7B26301F0E82F1E6001CE27F /* libevent.xcodeproj */,
+				32AC71890F2E4F62002BDDC8 /* libjpeg.xcodeproj */,
 				E4562A2A0E27CA2F005E4685 /* libpng.xcodeproj */,
 				829E30D60DBFD8ED00819EBF /* skia.xcodeproj */,
 				E4562A3B0E27CAB6005E4685 /* zlib.xcodeproj */,
@@ -1087,6 +1118,9 @@
 		825403B40D92D2EC0006B936 /* gfx */ = {
 			isa = PBXGroup;
 			children = (
+				32AC71B60F2E530F002BDDC8 /* jpeg_codec.cc */,
+				32AC71B70F2E530F002BDDC8 /* jpeg_codec.h */,
+				32AC71B50F2E52FC002BDDC8 /* jpeg_codec_unittest.cc */,
 				825403C80D92D31D0006B936 /* native_theme.cc */,
 				825403C90D92D31D0006B936 /* native_theme.h */,
 				7B8505A20E5B3FBE00730B43 /* native_theme_unittest.cc */,
@@ -1170,6 +1204,7 @@
 				7B836AD80E55094000F6AD31 /* PBXTargetDependency */,
 				7B836ADA0E55094000F6AD31 /* PBXTargetDependency */,
 				7B2630260E82F1EF001CE27F /* PBXTargetDependency */,
+				3236FBC90F2E9FC8005DC6EF /* PBXTargetDependency */,
 				7B8506290E5B556100730B43 /* PBXTargetDependency */,
 				7B4DF5340E5B6A58004D7619 /* PBXTargetDependency */,
 				7B8506310E5B55A200730B43 /* PBXTargetDependency */,
@@ -1204,6 +1239,10 @@
 					ProjectRef = 7B26301F0E82F1E6001CE27F /* libevent.xcodeproj */;
 				},
 				{
+					ProductGroup = 32AC718A0F2E4F62002BDDC8 /* Products */;
+					ProjectRef = 32AC71890F2E4F62002BDDC8 /* libjpeg.xcodeproj */;
+				},
+				{
 					ProductGroup = 7B165D5A0E55081400185273 /* Products */;
 					ProjectRef = E4562A2A0E27CA2F005E4685 /* libpng.xcodeproj */;
 				},
@@ -1228,6 +1267,13 @@
 /* End PBXProject section */
 
 /* Begin PBXReferenceProxy section */
+		32AC718E0F2E4F62002BDDC8 /* libjpeg.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libjpeg.a;
+			remoteRef = 32AC718D0F2E4F62002BDDC8 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
 		7B165D300E55081000185273 /* libgtest.a */ = {
 			isa = PBXReferenceProxy;
 			fileType = archive.ar;
@@ -1442,6 +1488,7 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				32AC71BF0F2E5421002BDDC8 /* jpeg_codec.cc in Sources */,
 				825403EE0D92D31D0006B936 /* png_decoder.cc in Sources */,
 				825403F00D92D31D0006B936 /* png_encoder.cc in Sources */,
 				825403F20D92D31D0006B936 /* point.cc in Sources */,
@@ -1466,6 +1513,7 @@
 				93611B1A0E5A878400F9405D /* histogram_unittest.cc in Sources */,
 				7BAE392B0E6F4EF200C3F750 /* hmac_unittest.cc in Sources */,
 				B57E4D780E9C26340090055D /* idletimer_unittest.cc in Sources */,
+				32AC71B80F2E5321002BDDC8 /* jpeg_codec_unittest.cc in Sources */,
 				7B78D3920E54FE0100609465 /* json_reader_unittest.cc in Sources */,
 				7B78D3930E54FE0100609465 /* json_writer_unittest.cc in Sources */,
 				7BF892E00E758883000BAF8A /* lazy_instance_unittest.cc in Sources */,
@@ -1513,6 +1561,11 @@
 /* End PBXSourcesBuildPhase section */
 
 /* Begin PBXTargetDependency section */
+		3236FBC90F2E9FC8005DC6EF /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			name = libjpeg;
+			targetProxy = 3236FBC80F2E9FC8005DC6EF /* PBXContainerItemProxy */;
+		};
 		7B2630260E82F1EF001CE27F /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			name = libevent;
@@ -1637,6 +1690,7 @@
 					..,
 					../skia/include,
 					../skia/include/corecg,
+					../third_party/libjpeg,
 					../third_party/libpng,
 				);
 				PRODUCT_NAME = base_gfx;
diff --git a/base/base_unittests.scons b/base/base_unittests.scons
index a7ea02f..48eaef8 100644
--- a/base/base_unittests.scons
+++ b/base/base_unittests.scons
@@ -15,6 +15,7 @@ env.ApplySConscript([
     '$BASE_DIR/gfx/using_base_gfx.scons',
     '$GTEST_DIR/../using_gtest.scons',
     '$ICU38_DIR/using_icu38.scons',
+    '$LIBJPEG_DIR/using_libjpeg.scons',
     '$LIBPNG_DIR/using_libpng.scons',
     '$SKIA_DIR/using_skia.scons',
     '$ZLIB_DIR/using_zlib.scons',
@@ -120,6 +121,7 @@ input_files = ChromeFileList([
   ]),
 
   MSVSFilter('gfx_tests', [
+    'gfx/jpeg_codec_unittest.cc',
     'gfx/png_codec_unittest.cc',
   ]),
 ])
diff --git a/base/build/base_gfx.vcproj b/base/build/base_gfx.vcproj
index 70875a9..b19945a 100644
--- a/base/build/base_gfx.vcproj
+++ b/base/build/base_gfx.vcproj
@@ -122,6 +122,14 @@
 	</References>
 	<Files>
 		<File
+			RelativePath="..\gfx\jpeg_codec.cc"
+			>
+		</File>
+		<File
+			RelativePath="..\gfx\jpeg_codec.h"
+			>
+		</File>
+		<File
 			RelativePath="..\gfx\gdi_util.cc"
 			>
 		</File>
diff --git a/base/build/base_gfx.vsprops b/base/build/base_gfx.vsprops
index 9dc5341..2ddeb0a 100644
--- a/base/build/base_gfx.vsprops
+++ b/base/build/base_gfx.vsprops
@@ -3,6 +3,6 @@
 	ProjectType="Visual C++"
 	Version="8.00"
 	Name="base_gfx"
-	InheritedPropertySheets="$(SolutionDir)..\build\common.vsprops;$(SolutionDir)..\third_party\icu38\build\using_icu.vsprops;$(SolutionDir)..\third_party\libpng\using_libpng.vsprops;$(SolutionDir)..\third_party\zlib\using_zlib.vsprops;..\..\skia\using_skia.vsprops"
+	InheritedPropertySheets="$(SolutionDir)..\build\common.vsprops;$(SolutionDir)..\third_party\icu38\build\using_icu.vsprops;$(SolutionDir)..\third_party\libjpeg\using_libjpeg.vsprops;$(SolutionDir)..\third_party\libpng\using_libpng.vsprops;$(SolutionDir)..\third_party\zlib\using_zlib.vsprops;..\..\skia\using_skia.vsprops"
 	>
 </VisualStudioPropertySheet>
diff --git a/base/build/base_unittests.vcproj b/base/build/base_unittests.vcproj
index a35fcc4..22df2c8 100644
--- a/base/build/base_unittests.vcproj
+++ b/base/build/base_unittests.vcproj
@@ -412,6 +412,10 @@
 			Name="gfx_tests"
 			>
 			<File
+				RelativePath="..\gfx\jpeg_codec_unittest.cc"
+				>
+			</File>
+			<File
 				RelativePath="..\gfx\png_codec_unittest.cc"
 				>
 			</File>
diff --git a/base/gfx/base_gfx.scons b/base/gfx/base_gfx.scons
index ceb663b..4c93190 100644
--- a/base/gfx/base_gfx.scons
+++ b/base/gfx/base_gfx.scons
@@ -12,6 +12,7 @@ env = env.Clone()
 
 env.ApplySConscript([
     '$ICU38_DIR/using_icu38.scons',
+    '$LIBJPEG_DIR/using_libjpeg.scons',
     '$LIBPNG_DIR/using_libpng.scons',
     '$SKIA_DIR/using_skia.scons',
     '$ZLIB_DIR/using_zlib.scons',
@@ -25,6 +26,8 @@ if env.Bit('windows'):
   )
 
 input_files = ChromeFileList([
+    'jpeg_codec.cc',
+    'jpeg_codec.h',
     'gdi_util.cc',
     'gdi_util.h',
     'native_theme.cc',
diff --git a/base/gfx/jpeg_codec.cc b/base/gfx/jpeg_codec.cc
new file mode 100644
index 0000000..f78d5af
--- /dev/null
+++ b/base/gfx/jpeg_codec.cc
@@ -0,0 +1,522 @@
+// 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 "base/gfx/jpeg_codec.h"
+
+#include <setjmp.h>
+
+#include "base/logging.h"
+#include "base/scoped_ptr.h"
+#include "skia/include/SkBitmap.h"
+
+extern "C" {
+#include "jpeglib.h"
+}
+
+// Encoder/decoder shared stuff ------------------------------------------------
+
+namespace {
+
+// used to pass error info through the JPEG library
+struct CoderErrorMgr {
+  jpeg_error_mgr pub;
+  jmp_buf setjmp_buffer;
+};
+
+void ErrorExit(jpeg_common_struct* cinfo) {
+  CoderErrorMgr *err = reinterpret_cast<CoderErrorMgr*>(cinfo->err);
+
+  // Return control to the setjmp point.
+  longjmp(err->setjmp_buffer, false);
+}
+
+}  // namespace
+
+// Encoder ---------------------------------------------------------------------
+//
+// This code is based on nsJPEGEncoder from Mozilla.
+// Copyright 2005 Google Inc. (Brett Wilson, contributor)
+
+namespace {
+
+// Initial size for the output buffer in the JpegEncoderState below.
+const static int initial_output_buffer_size = 8192;
+
+struct JpegEncoderState {
+  JpegEncoderState(std::vector<unsigned char>* o) : out(o), image_buffer_used(0) {
+  }
+
+  // Output buffer, of which 'image_buffer_used' bytes are actually used (this
+  // will often be less than the actual size of the vector because we size it
+  // so that libjpeg can write directly into it.
+  std::vector<unsigned char>* out;
+
+  // Number of bytes in the 'out' buffer that are actually used (see above).
+  size_t image_buffer_used;
+};
+
+// Initializes the JpegEncoderState for encoding, and tells libjpeg about where
+// the output buffer is.
+//
+// From the JPEG library:
+//  "Initialize destination. This is called by jpeg_start_compress() before
+//   any data is actually written. It must initialize next_output_byte and
+//   free_in_buffer. free_in_buffer must be initialized to a positive value."
+void InitDestination(jpeg_compress_struct* cinfo) {
+  JpegEncoderState* state = static_cast<JpegEncoderState*>(cinfo->client_data);
+  DCHECK(state->image_buffer_used == 0) << "initializing after use";
+
+  state->out->resize(initial_output_buffer_size);
+  state->image_buffer_used = 0;
+
+  cinfo->dest->next_output_byte = &(*state->out)[0];
+  cinfo->dest->free_in_buffer = initial_output_buffer_size;
+}
+
+// Resize the buffer that we give to libjpeg and update our and its state.
+//
+// From the JPEG library:
+//  "Callback used by libjpeg whenever the buffer has filled (free_in_buffer
+//   reaches zero). In typical applications, it should write out the *entire*
+//   buffer (use the saved start address and buffer length; ignore the current
+//   state of next_output_byte and free_in_buffer). Then reset the pointer &
+//   count to the start of the buffer, and return TRUE indicating that the
+//   buffer has been dumped. free_in_buffer must be set to a positive value
+//   when TRUE is returned. A FALSE return should only be used when I/O
+//   suspension is desired (this operating mode is discussed in the next
+//   section)."
+boolean EmptyOutputBuffer(jpeg_compress_struct* cinfo) {
+  JpegEncoderState* state = static_cast<JpegEncoderState*>(cinfo->client_data);
+
+  // note the new size, the buffer is full
+  state->image_buffer_used = state->out->size();
+
+  // expand buffer, just double size each time
+  state->out->resize(state->out->size() * 2);
+
+  // tell libjpeg where to write the next data
+  cinfo->dest->next_output_byte = &(*state->out)[state->image_buffer_used];
+  cinfo->dest->free_in_buffer = state->out->size() - state->image_buffer_used;
+  return 1;
+}
+
+// Cleans up the JpegEncoderState to prepare for returning in the final form.
+//
+// From the JPEG library:
+//  "Terminate destination --- called by jpeg_finish_compress() after all data
+//   has been written. In most applications, this must flush any data
+//   remaining in the buffer. Use either next_output_byte or free_in_buffer to
+//   determine how much data is in the buffer."
+void TermDestination(jpeg_compress_struct* cinfo) {
+  JpegEncoderState* state = static_cast<JpegEncoderState*>(cinfo->client_data);
+  DCHECK(state->out->size() >= state->image_buffer_used);
+
+  // update the used byte based on the next byte libjpeg would write to
+  state->image_buffer_used = cinfo->dest->next_output_byte - &(*state->out)[0];
+  DCHECK(state->image_buffer_used < state->out->size()) <<
+    "JPEG library busted, got a bad image buffer size";
+
+  // update our buffer so that it exactly encompases the desired data
+  state->out->resize(state->image_buffer_used);
+}
+
+// Converts RGBA to RGB (removing the alpha values) to prepare to send data to
+// libjpeg. This converts one row of data in rgba with the given width in
+// pixels the the given rgb destination buffer (which should have enough space
+// reserved for the final data).
+void StripAlpha(const unsigned char* rgba, int pixel_width, unsigned char* rgb)
+{
+  for (int x = 0; x < pixel_width; x++) {
+    const unsigned char* pixel_in = &rgba[x * 4];
+    unsigned char* pixel_out = &rgb[x * 3];
+    pixel_out[0] = pixel_in[0];
+    pixel_out[1] = pixel_in[1];
+    pixel_out[2] = pixel_in[2];
+  }
+}
+
+// Converts BGRA to RGB by reordering the color components and dropping the
+// alpha. This converts  one row of data in rgba with the given width in
+// pixels the the given rgb destination buffer (which should have enough space
+// reserved for the final data).
+void BGRAtoRGB(const unsigned char* bgra, int pixel_width, unsigned char* rgb)
+{
+  for (int x = 0; x < pixel_width; x++) {
+    const unsigned char* pixel_in = &bgra[x * 4];
+    unsigned char* pixel_out = &rgb[x * 3];
+    pixel_out[0] = pixel_in[2];
+    pixel_out[1] = pixel_in[1];
+    pixel_out[2] = pixel_in[0];
+  }
+}
+
+// This class destroys the given jpeg_compress object when it goes out of
+// scope. It simplifies the error handling in Encode (and even applies to the
+// success case).
+class CompressDestroyer {
+ public:
+  CompressDestroyer() : cinfo_(NULL) {
+  }
+  ~CompressDestroyer() {
+    DestroyManagedObject();
+  }
+  void SetManagedObject(jpeg_compress_struct* ci) {
+    DestroyManagedObject();
+    cinfo_ = ci;
+  }
+  void DestroyManagedObject() {
+    if (cinfo_) {
+      jpeg_destroy_compress(cinfo_);
+      cinfo_ = NULL;
+    }
+  }
+ private:
+  jpeg_compress_struct* cinfo_;
+};
+
+}  // namespace
+
+bool JPEGCodec::Encode(const unsigned char* input, ColorFormat format,
+                       int w, int h, int row_byte_width,
+                       int quality, std::vector<unsigned char>* output) {
+  jpeg_compress_struct cinfo;
+  CompressDestroyer destroyer;
+  output->clear();
+
+  // We set up the normal JPEG error routines, then override error_exit.
+  // This must be done before the call to create_compress.
+  CoderErrorMgr errmgr;
+  cinfo.err = jpeg_std_error(&errmgr.pub);
+  errmgr.pub.error_exit = ErrorExit;
+  // Establish the setjmp return context for ErrorExit to use.
+  if (setjmp(errmgr.setjmp_buffer)) {
+    // If we get here, the JPEG code has signaled an error.
+    // MSDN notes: "if you intend your code to be portable, do not rely on
+    // correct destruction of frame-based objects when executing a nonlocal
+    // goto using a call to longjmp."  So we delete the CompressDestroyer's
+    // object manually instead.
+    destroyer.DestroyManagedObject();
+    return false;
+  }
+
+  // The destroyer will destroy() cinfo on exit.
+  jpeg_create_compress(&cinfo);
+  destroyer.SetManagedObject(&cinfo);
+
+  cinfo.image_width = w;
+  cinfo.image_height = h;
+  cinfo.input_components = 3;
+  cinfo.in_color_space = JCS_RGB;
+  cinfo.data_precision = 8;
+
+  jpeg_set_defaults(&cinfo);
+  jpeg_set_quality(&cinfo, quality, 1);  // quality here is 0-100
+
+  // set up the destination manager
+  jpeg_destination_mgr destmgr;
+  destmgr.init_destination = InitDestination;
+  destmgr.empty_output_buffer = EmptyOutputBuffer;
+  destmgr.term_destination = TermDestination;
+  cinfo.dest = &destmgr;
+
+  JpegEncoderState state(output);
+  cinfo.client_data = &state;
+
+  jpeg_start_compress(&cinfo, 1);
+
+  // feed it the rows, doing necessary conversions for the color format
+  if (format == FORMAT_RGB) {
+    // no conversion necessary
+    while (cinfo.next_scanline < cinfo.image_height) {
+      const unsigned char* row = &input[cinfo.next_scanline * row_byte_width];
+      jpeg_write_scanlines(&cinfo, const_cast<unsigned char**>(&row), 1);
+    }
+  } else {
+    // get the correct format converter
+    void (*converter)(const unsigned char* in, int w, unsigned char* rgb);
+    if (format == FORMAT_RGBA) {
+      converter = StripAlpha;
+    } else if (format == FORMAT_BGRA) {
+      converter = BGRAtoRGB;
+    } else {
+      NOTREACHED() << "Invalid pixel format";
+      return false;
+    }
+
+    // output row after converting
+    unsigned char* row = new unsigned char[w * 3];
+
+    while (cinfo.next_scanline < cinfo.image_height) {
+      converter(&input[cinfo.next_scanline * row_byte_width], w, row);
+      jpeg_write_scanlines(&cinfo, &row, 1);
+    }
+    delete[] row;
+  }
+
+  jpeg_finish_compress(&cinfo);
+  return true;
+}
+
+// Decoder --------------------------------------------------------------------
+
+namespace {
+
+struct JpegDecoderState {
+  JpegDecoderState(const unsigned char* in, size_t len)
+      : input_buffer(in), input_buffer_length(len) {
+  }
+
+  const unsigned char* input_buffer;
+  size_t input_buffer_length;
+};
+
+// Callback to initialize the source.
+//
+// From the JPEG library:
+//  "Initialize source. This is called by jpeg_read_header() before any data is
+//   actually read. May leave bytes_in_buffer set to 0 (in which case a
+//   fill_input_buffer() call will occur immediately)."
+void InitSource(j_decompress_ptr cinfo) {
+  JpegDecoderState* state = static_cast<JpegDecoderState*>(cinfo->client_data);
+  cinfo->src->next_input_byte = state->input_buffer;
+  cinfo->src->bytes_in_buffer = state->input_buffer_length;
+}
+
+// Callback to fill the buffer. Since our buffer already contains all the data,
+// we should never need to provide more data. If libjpeg thinks it needs more
+// data, our input is probably corrupt.
+//
+// From the JPEG library:
+//  "This is called whenever bytes_in_buffer has reached zero and more data is
+//   wanted. In typical applications, it should read fresh data into the buffer
+//   (ignoring the current state of next_input_byte and bytes_in_buffer), reset
+//   the pointer & count to the start of the buffer, and return TRUE indicating
+//   that the buffer has been reloaded. It is not necessary to fill the buffer
+//   entirely, only to obtain at least one more byte. bytes_in_buffer MUST be
+//   set to a positive value if TRUE is returned. A FALSE return should only
+//   be used when I/O suspension is desired."
+boolean FillInputBuffer(j_decompress_ptr cinfo) {
+  return false;
+}
+
+// Skip data in the buffer. Since we have all the data at once, this operation
+// is easy. It is not clear if this ever gets called because the JPEG library
+// should be able to do the skip itself (it has all the data).
+//
+// From the JPEG library:
+//  "Skip num_bytes worth of data. The buffer pointer and count should be
+//   advanced over num_bytes input bytes, refilling the buffer as needed. This
+//   is used to skip over a potentially large amount of uninteresting data
+//   (such as an APPn marker). In some applications it may be possible to
+//   optimize away the reading of the skipped data, but it's not clear that
+//   being smart is worth much trouble; large skips are uncommon.
+//   bytes_in_buffer may be zero on return. A zero or negative skip count
+//   should be treated as a no-op."
+void SkipInputData(j_decompress_ptr cinfo, long num_bytes) {
+  if (num_bytes > static_cast<long>(cinfo->src->bytes_in_buffer)) {
+    // Since all our data should be in the buffer, trying to skip beyond it
+    // means that there is some kind of error or corrupt input data. A 0 for
+    // bytes left means it will call FillInputBuffer which will then fail.
+    cinfo->src->next_input_byte += cinfo->src->bytes_in_buffer;
+    cinfo->src->bytes_in_buffer = 0;
+  } else if (num_bytes > 0) {
+    cinfo->src->bytes_in_buffer -= static_cast<size_t>(num_bytes);
+    cinfo->src->next_input_byte += num_bytes;
+  }
+}
+
+// Our source doesn't need any cleanup, so this is a NOP.
+//
+// From the JPEG library:
+//  "Terminate source --- called by jpeg_finish_decompress() after all data has
+//   been read to clean up JPEG source manager. NOT called by jpeg_abort() or
+//   jpeg_destroy()."
+void TermSource(j_decompress_ptr cinfo) {
+}
+
+// Converts one row of rgb data to rgba data by adding a fully-opaque alpha
+// value.
+void AddAlpha(const unsigned char* rgb, int pixel_width, unsigned char* rgba) {
+  for (int x = 0; x < pixel_width; x++) {
+    const unsigned char* pixel_in = &rgb[x * 3];
+    unsigned char* pixel_out = &rgba[x * 4];
+    pixel_out[0] = pixel_in[0];
+    pixel_out[1] = pixel_in[1];
+    pixel_out[2] = pixel_in[2];
+    pixel_out[3] = 0xff;
+  }
+}
+
+// Converts one row of RGB data to BGRA by reordering the color components and
+// adding alpha values of 0xff.
+void RGBtoBGRA(const unsigned char* bgra, int pixel_width, unsigned char* rgb)
+{
+  for (int x = 0; x < pixel_width; x++) {
+    const unsigned char* pixel_in = &bgra[x * 3];
+    unsigned char* pixel_out = &rgb[x * 4];
+    pixel_out[0] = pixel_in[2];
+    pixel_out[1] = pixel_in[1];
+    pixel_out[2] = pixel_in[0];
+    pixel_out[3] = 0xff;
+  }
+}
+
+// This class destroys the given jpeg_decompress object when it goes out of
+// scope. It simplifies the error handling in Decode (and even applies to the
+// success case).
+class DecompressDestroyer {
+ public:
+  DecompressDestroyer() : cinfo_(NULL) {
+  }
+  ~DecompressDestroyer() {
+    DestroyManagedObject();
+  }
+  void SetManagedObject(jpeg_decompress_struct* ci) {
+    DestroyManagedObject();
+    cinfo_ = ci;
+  }
+  void DestroyManagedObject() {
+    if (cinfo_) {
+      jpeg_destroy_decompress(cinfo_);
+      cinfo_ = NULL;
+    }
+  }
+ private:
+  jpeg_decompress_struct* cinfo_;
+};
+
+}  // namespace
+
+bool JPEGCodec::Decode(const unsigned char* input, size_t input_size,
+                       ColorFormat format, std::vector<unsigned char>* output,
+                       int* w, int* h) {
+  jpeg_decompress_struct cinfo;
+  DecompressDestroyer destroyer;
+  output->clear();
+
+  // We set up the normal JPEG error routines, then override error_exit.
+  // This must be done before the call to create_decompress.
+  CoderErrorMgr errmgr;
+  cinfo.err = jpeg_std_error(&errmgr.pub);
+  errmgr.pub.error_exit = ErrorExit;
+  // Establish the setjmp return context for ErrorExit to use.
+  if (setjmp(errmgr.setjmp_buffer)) {
+    // If we get here, the JPEG code has signaled an error.
+    // See note in JPEGCodec::Encode() for why we need to destroy the cinfo
+    // manually here.
+    destroyer.DestroyManagedObject();
+    return false;
+  }
+
+  // The destroyer will destroy() cinfo on exit.  We don't want to set the
+  // destroyer's object until cinfo is initialized.
+  jpeg_create_decompress(&cinfo);
+  destroyer.SetManagedObject(&cinfo);
+
+  // set up the source manager
+  jpeg_source_mgr srcmgr;
+  srcmgr.init_source = InitSource;
+  srcmgr.fill_input_buffer = FillInputBuffer;
+  srcmgr.skip_input_data = SkipInputData;
+  srcmgr.resync_to_restart = jpeg_resync_to_restart;  // use default routine
+  srcmgr.term_source = TermSource;
+  cinfo.src = &srcmgr;
+
+  JpegDecoderState state(input, input_size);
+  cinfo.client_data = &state;
+
+  // fill the file metadata into our buffer
+  if (jpeg_read_header(&cinfo, true) != JPEG_HEADER_OK)
+    return false;
+
+  // we want to always get RGB data out
+  switch (cinfo.jpeg_color_space) {
+    case JCS_GRAYSCALE:
+    case JCS_RGB:
+    case JCS_YCbCr:
+      cinfo.out_color_space = JCS_RGB;
+      break;
+    case JCS_CMYK:
+    case JCS_YCCK:
+    default:
+      // Mozilla errors out on these color spaces, so I presume that the jpeg
+      // library can't do automatic color space conversion for them. We don't
+      // care about these anyway.
+      return false;
+  }
+  cinfo.output_components = 3;
+
+  jpeg_calc_output_dimensions(&cinfo);
+  *w = cinfo.output_width;
+  *h = cinfo.output_height;
+
+  jpeg_start_decompress(&cinfo);
+
+  // FIXME(brettw) we may want to allow the capability for callers to request
+  // how to align row lengths as we do for the compressor.
+  int row_read_stride = cinfo.output_width * cinfo.output_components;
+
+  if (format == FORMAT_RGB) {
+    // easy case, row needs no conversion
+    int row_write_stride = row_read_stride;
+    output->resize(row_write_stride * cinfo.output_height);
+
+    for (int row = 0; row < static_cast<int>(cinfo.output_height); row++) {
+      unsigned char* rowptr = &(*output)[row * row_write_stride];
+      if (!jpeg_read_scanlines(&cinfo, &rowptr, 1))
+        return false;
+    }
+  } else {
+    // Rows need conversion to output format: read into a temporary buffer and
+    // expand to the final one. Performance: we could avoid the extra
+    // allocation by doing the expansion in-place.
+    int row_write_stride;
+    void (*converter)(const unsigned char* rgb, int w, unsigned char* out);
+    if (format == FORMAT_RGBA) {
+      row_write_stride = cinfo.output_width * 4;
+      converter = AddAlpha;
+    } else if (format == FORMAT_BGRA) {
+      row_write_stride = cinfo.output_width * 4;
+      converter = RGBtoBGRA;
+    } else {
+      NOTREACHED() << "Invalid pixel format";
+      jpeg_destroy_decompress(&cinfo);
+      return false;
+    }
+
+    output->resize(row_write_stride * cinfo.output_height);
+
+    scoped_array<unsigned char> row_data(new unsigned char[row_read_stride]);
+    unsigned char* rowptr = row_data.get();
+    for (int row = 0; row < static_cast<int>(cinfo.output_height); row++) {
+      if (!jpeg_read_scanlines(&cinfo, &rowptr, 1))
+        return false;
+      converter(rowptr, *w, &(*output)[row * row_write_stride]);
+    }
+  }
+
+  jpeg_finish_decompress(&cinfo);
+  jpeg_destroy_decompress(&cinfo);
+  return true;
+}
+
+// static
+SkBitmap* JPEGCodec::Decode(const unsigned char* input, size_t input_size) {
+  int w, h;
+  std::vector<unsigned char> data_vector;
+  // Use FORMAT_BGRA as that maps to Skia's 32 bit (kARGB_8888_Config) format.
+  if (!Decode(input, input_size, FORMAT_BGRA, &data_vector, &w, &h))
+    return NULL;
+
+  // Skia only handles 32 bit images.
+  int data_length = w * h * 4;
+
+  SkBitmap* bitmap = new SkBitmap();
+  bitmap->setConfig(SkBitmap::kARGB_8888_Config, w, h);
+  bitmap->allocPixels();
+  memcpy(bitmap->getAddr32(0, 0), &data_vector[0], data_length);
+
+  return bitmap;
+}
+
diff --git a/base/gfx/jpeg_codec.h b/base/gfx/jpeg_codec.h
new file mode 100644
index 0000000..141c00e
--- /dev/null
+++ b/base/gfx/jpeg_codec.h
@@ -0,0 +1,60 @@
+// 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 BASE_GFX_JPEG_CODEC_H_
+#define BASE_GFX_JPEG_CODEC_H_
+
+#include <vector>
+
+class SkBitmap;
+
+// Interface for encoding/decoding JPEG data. This is a wrapper around libjpeg,
+// which has an inconvenient interface for callers. This is only used for UI
+// elements, WebKit has its own more complicated JPEG decoder which handles,
+// among other things, partially downloaded data.
+class JPEGCodec {
+ public:
+  enum ColorFormat {
+    // 3 bytes per pixel (packed), in RGB order regardless of endianness.
+    // This is the native JPEG format.
+    FORMAT_RGB,
+
+    // 4 bytes per pixel, in RGBA order in mem regardless of endianness.
+    FORMAT_RGBA,
+
+    // 4 bytes per pixel, in BGRA order in mem regardless of endianness.
+    // This is the default Windows DIB order.
+    FORMAT_BGRA
+  };
+
+  // Encodes the given raw 'input' data, with each pixel being represented as
+  // given in 'format'. The encoded JPEG data will be written into the supplied
+  // vector and true will be returned on success. On failure (false), the
+  // contents of the output buffer are undefined.
+  //
+  // w, h: dimensions of the image
+  // row_byte_width: the width in bytes of each row. This may be greater than
+  //   w * bytes_per_pixel if there is extra padding at the end of each row
+  //   (often, each row is padded to the next machine word).
+  // quality: an integer in the range 0-100, where 100 is the highest quality.
+  static bool Encode(const unsigned char* input, ColorFormat format,
+                     int w, int h, int row_byte_width,
+                     int quality, std::vector<unsigned char>* output);
+
+  // Decodes the JPEG data contained in input of length input_size. The
+  // decoded data will be placed in *output with the dimensions in *w and *h
+  // on success (returns true). This data will be written in the'format'
+  // format. On failure, the values of these output variables is undefined.
+  static bool Decode(const unsigned char* input, size_t input_size,
+                     ColorFormat format, std::vector<unsigned char>* output,
+                     int* w, int* h);
+
+  // Decodes the JPEG data contained in input of length input_size. If
+  // successful, a SkBitmap is created and returned. It is up to the caller
+  // to delete the returned bitmap.
+  static SkBitmap* Decode(const unsigned char* input, size_t input_size);
+};
+
+#endif  // BASE_GFX_JPEG_CODEC_H_
+
diff --git a/base/gfx/jpeg_codec_unittest.cc b/base/gfx/jpeg_codec_unittest.cc
new file mode 100644
index 0000000..0a58630
--- /dev/null
+++ b/base/gfx/jpeg_codec_unittest.cc
@@ -0,0 +1,147 @@
+// 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 <math.h>
+
+#include "base/gfx/jpeg_codec.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+// out of 100, this indicates how compressed it will be, this should be changed
+// with jpeg equality threshold
+// static int jpeg_quality = 75;  // FIXME(brettw)
+static int jpeg_quality = 100;
+
+// The threshold of average color differences where we consider two images
+// equal. This number was picked to be a little above the observed difference
+// using the above quality.
+static double jpeg_equality_threshold = 1.0;
+
+// Computes the average difference between each value in a and b. A and b
+// should be the same size. Used to see if two images are approximately equal
+// in the presence of compression.
+static double AveragePixelDelta(const std::vector<unsigned char>& a,
+                                const std::vector<unsigned char>& b) {
+  // if the sizes are different, say the average difference is the maximum
+  if (a.size() != b.size())
+    return 255.0;
+  if (a.size() == 0)
+    return 0;  // prevent divide by 0 below
+
+  double acc = 0.0;
+  for (size_t i = 0; i < a.size(); i++)
+    acc += fabs(static_cast<double>(a[i]) - static_cast<double>(b[i]));
+
+  return acc / static_cast<double>(a.size());
+}
+
+static void MakeRGBImage(int w, int h, std::vector<unsigned char>* dat) {
+  dat->resize(w * h * 3);
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      unsigned char* org_px = &(*dat)[(y * w + x) * 3];
+      org_px[0] = x * 3;      // r
+      org_px[1] = x * 3 + 1;  // g
+      org_px[2] = x * 3 + 2;  // b
+    }
+  }
+}
+
+TEST(JPEGCodec, EncodeDecodeRGB) {
+  int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeRGBImage(w, h, &original);
+
+  // encode, making sure it was compressed some
+  std::vector<unsigned char> encoded;
+  EXPECT_TRUE(JPEGCodec::Encode(&original[0], JPEGCodec::FORMAT_RGB, w, h,
+                                w * 3, jpeg_quality, &encoded));
+  EXPECT_GT(original.size(), encoded.size());
+
+  // decode, it should have the same size as the original
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  EXPECT_TRUE(JPEGCodec::Decode(&encoded[0], encoded.size(),
+                                JPEGCodec::FORMAT_RGB, &decoded,
+                                &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original.size(), decoded.size());
+
+  // Images must be approximately equal (compression will have introduced some
+  // minor artifacts).
+  ASSERT_GE(jpeg_equality_threshold, AveragePixelDelta(original, decoded));
+}
+
+TEST(JPEGCodec, EncodeDecodeRGBA) {
+  int w = 20, h = 20;
+
+  // create an image with known values, a must be opaque because it will be
+  // lost during compression
+  std::vector<unsigned char> original;
+  original.resize(w * h * 4);
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      unsigned char* org_px = &original[(y * w + x) * 4];
+      org_px[0] = x * 3;      // r
+      org_px[1] = x * 3 + 1;  // g
+      org_px[2] = x * 3 + 2;  // b
+      org_px[3] = 0xFF;       // a (opaque)
+    }
+  }
+
+  // encode, making sure it was compressed some
+  std::vector<unsigned char> encoded;
+  EXPECT_TRUE(JPEGCodec::Encode(&original[0], JPEGCodec::FORMAT_RGBA, w, h,
+                                w * 4, jpeg_quality, &encoded));
+  EXPECT_GT(original.size(), encoded.size());
+
+  // decode, it should have the same size as the original
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  EXPECT_TRUE(JPEGCodec::Decode(&encoded[0], encoded.size(),
+                                JPEGCodec::FORMAT_RGBA, &decoded,
+                                &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original.size(), decoded.size());
+
+  // Images must be approximately equal (compression will have introduced some
+  // minor artifacts).
+  ASSERT_GE(jpeg_equality_threshold, AveragePixelDelta(original, decoded));
+}
+
+// Test that corrupted data decompression causes failures.
+TEST(JPEGCodec, DecodeCorrupted) {
+  int w = 20, h = 20;
+
+  // some random data (an uncompressed image)
+  std::vector<unsigned char> original;
+  MakeRGBImage(w, h, &original);
+
+  // it should fail when given non-JPEG compressed data
+  std::vector<unsigned char> output;
+  int outw, outh;
+  ASSERT_FALSE(JPEGCodec::Decode(&original[0], original.size(),
+                                 JPEGCodec::FORMAT_RGB, &output,
+                                 &outw, &outh));
+
+  // make some compressed data
+  std::vector<unsigned char> compressed;
+  ASSERT_TRUE(JPEGCodec::Encode(&original[0], JPEGCodec::FORMAT_RGB, w, h,
+                                w * 3, jpeg_quality, &compressed));
+
+  // try decompressing a truncated version
+  ASSERT_FALSE(JPEGCodec::Decode(&compressed[0], compressed.size() / 2,
+                                 JPEGCodec::FORMAT_RGB, &output,
+                                 &outw, &outh));
+
+  // corrupt it and try decompressing that
+  for (int i = 10; i < 30; i++)
+    compressed[i] = i;
+  ASSERT_FALSE(JPEGCodec::Decode(&compressed[0], compressed.size(),
+                                 JPEGCodec::FORMAT_RGB, &output,
+                                 &outw, &outh));
+}