diff --git a/dashboard/overview.html b/dashboard/overview.html
index 0c3894a..69fc7e9 100644
--- a/dashboard/overview.html
+++ b/dashboard/overview.html
@@ -91,6 +91,7 @@
         </tr>
         <tr>
             <script>DisplayGraph("android-gn/kraken");</script>
+            <script>DisplayGraph("android-gn/cc_perftests");</script>
         </tr>
       </table>
       <h1 id="Chromium-Android-Nexus4">Android Nexus4</h1>
@@ -107,6 +108,7 @@
         </tr>
         <tr>
             <script>DisplayGraph("android-nexus4/kraken");</script>
+            <script>DisplayGraph("android-nexus4/cc_perftests");</script>
         </tr>
       </table>
       <h1 id="Chromium-Android-Nexus10">Android Nexus10</h1>
@@ -123,6 +125,7 @@
         </tr>
         <tr>
             <script>DisplayGraph("android-nexus10/kraken");</script>
+            <script>DisplayGraph("android-nexus10/cc_perftests");</script>
         </tr>
       </table>
       <h1 id="Chromium-XP-Dual-Core">XP Dual Core</h1>
@@ -233,6 +236,7 @@
         <tr>
             <script>DisplayGraph("chromium-rel-win7-gpu-ati/spaceport");</script>
             <script>DisplayGraph("chromium-rel-win7-gpu-ati/image_decoding_benchmark");</script>
+            <script>DisplayGraph("chromium-rel-win7-gpu-ati/cc_perftests");</script>
         </tr>
       </table>
 
@@ -246,6 +250,7 @@
         <tr>
             <script>DisplayGraph("chromium-rel-win7-gpu-intel/spaceport");</script>
             <script>DisplayGraph("chromium-rel-win7-gpu-intel/image_decoding_benchmark");</script>
+            <script>DisplayGraph("chromium-rel-win7-gpu-intel/cc_perftests");</script>
         </tr>
       </table>
 
@@ -259,6 +264,7 @@
         <tr>
             <script>DisplayGraph("chromium-rel-win7-gpu-nvidia/spaceport");</script>
             <script>DisplayGraph("chromium-rel-win7-gpu-nvidia/image_decoding_benchmark");</script>
+            <script>DisplayGraph("chromium-rel-win7-gpu-nvidia/cc_perftests");</script>
         </tr>
       </table>
 
@@ -304,6 +310,9 @@
             <script>DisplayGraph("endure-linux-rel/gmail-testGmailComposeDiscard", "GmailComposeDiscard-TabMem-Private", 0);</script>
             <script>DisplayGraph("endure-linux-dbg/gmail-testGmailComposeDiscard", "GmailComposeDiscard-l0-DMP", 0);</script>
         </tr>
+        <tr>
+            <script>DisplayGraph("linux-release/cc_perftests");</script>
+        </tr>
       </table>
       <h1 id="Chromium-Linux-LowMem">Linux LowMem</h1>
       <table>
@@ -380,6 +389,7 @@
         <tr>
             <script>DisplayGraph("chromium-rel-mac7-gpu-intel/spaceport");</script>
             <script>DisplayGraph("chromium-rel-mac7-gpu-intel/image_decoding_benchmark");</script>
+            <script>DisplayGraph("chromium-rel-mac7-gpu-intel/cc_perftests");</script>
         </tr>
       </table>
     </center>
diff --git a/generate_perf.py b/generate_perf.py
index e0da8ce..c30ff6b 100755
--- a/generate_perf.py
+++ b/generate_perf.py
@@ -120,6 +120,7 @@
   'avperf': 'Audio Video Perf',
   'av_perf': 'Audio Video Perf 2',
   'bloat-http': 'Bloat - HTTP',
+  'cc_perftests': 'Chrome Compositor Perf',
   'chrome_frame_perf': 'Chrome Frame Perf',
   'control-testControlAttachDetachDOMTree':
     'Control Test: ControlAttachDetachDOMTree',
@@ -225,7 +226,7 @@
 """
 
 # Template contents of a chrome_config.js file.  One is create in dashboard
-# directory.  This specifies all test names and machines that are running 
+# directory.  This specifies all test names and machines that are running
 # the tests.  This is used by Chrome dashboard HTML pages.
 CHROME_CONFIG_TEMPLATE = """\
 /*
