Fix up prerendering net-internals page and add some data:

  Fix memory leak, fix CSS.
  Add whether or not prerendering is enabled, add time.

BUG=none
TEST=PrerenderHistoryTest.GetAsValue

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

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

9 files changed, 82 insertions, 29 deletions

diff --git a/chrome/browser/prerender/prerender_history.cc b/chrome/browser/prerender/prerender_history.cc
index 1f2e16c..9f83a9e 100644
--- a/chrome/browser/prerender/prerender_history.cc
+++ b/chrome/browser/prerender/prerender_history.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/prerender/prerender_history.h"
 
 #include "base/logging.h"
+#include "base/string_number_conversions.h"
 #include "base/values.h"
 
 namespace prerender {
@@ -30,14 +31,22 @@ void PrerenderHistory::Clear() {
 
 Value* PrerenderHistory::GetEntriesAsValue() const {
   ListValue* return_list = new ListValue();
+  // Javascript needs times in terms of milliseconds since Jan 1, 1970.
+  base::Time epoch_start = base::Time::UnixEpoch();
   for (std::list<Entry>::const_reverse_iterator it = entries_.rbegin();
        it != entries_.rend();
        ++it) {
     const Entry& entry = *it;
-    DictionaryValue* v = new DictionaryValue();
-    v->SetString("url", entry.url.spec());
-    v->SetString("final_status", NameFromFinalStatus(entry.final_status));
-    return_list->Append(v);
+    DictionaryValue* entry_dict = new DictionaryValue();
+    entry_dict->SetString("url", entry.url.spec());
+    entry_dict->SetString("final_status",
+                          NameFromFinalStatus(entry.final_status));
+    // Use a string to prevent overflow, as Values don't support 64-bit
+    // integers.
+    entry_dict->SetString(
+        "end_time",
+        base::Int64ToString((entry.end_time - epoch_start).InMilliseconds()));
+    return_list->Append(entry_dict);
   }
   return return_list;
 }
diff --git a/chrome/browser/prerender/prerender_history.h b/chrome/browser/prerender/prerender_history.h
index 5bc009f..c9bd7b7 100644
--- a/chrome/browser/prerender/prerender_history.h
+++ b/chrome/browser/prerender/prerender_history.h
@@ -9,6 +9,7 @@
 #include <list>
 
 #include "base/threading/non_thread_safe.h"
+#include "base/time.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "googleurl/src/gurl.h"
 
@@ -26,8 +27,11 @@ class PrerenderHistory : public base::NonThreadSafe {
   struct Entry {
     Entry() : final_status(FINAL_STATUS_MAX) {}
 
-    Entry(const GURL& url_arg, FinalStatus final_status_arg)
-        : url(url_arg), final_status(final_status_arg) {
+    Entry(const GURL& url_arg,
+          FinalStatus final_status_arg,
+          base::Time end_time_arg)
+        : url(url_arg), final_status(final_status_arg),
+          end_time(end_time_arg) {
     }
 
     // The URL which was prerendered. This should be the URL included in the
@@ -38,6 +42,9 @@ class PrerenderHistory : public base::NonThreadSafe {
     // The FinalStatus describing whether the prerendered page was used or why
     // it was cancelled.
     FinalStatus final_status;
+
+    // Time the PrerenderContents was destroyed.
+    base::Time end_time;
   };
 
   // Creates a history with capacity for |max_items| entries.
diff --git a/chrome/browser/prerender/prerender_history_unittest.cc b/chrome/browser/prerender/prerender_history_unittest.cc
index f28dde4..84dcefa 100644
--- a/chrome/browser/prerender/prerender_history_unittest.cc
+++ b/chrome/browser/prerender/prerender_history_unittest.cc
@@ -14,13 +14,14 @@ namespace {
 bool ListEntryMatches(ListValue* list,
                       size_t index,
                       const char* expected_url,
-                      FinalStatus expected_final_status) {
+                      FinalStatus expected_final_status,
+                      const std::string& expected_end_time) {
   if (index >= list->GetSize())
     return false;
   DictionaryValue* dict = NULL;
   if (!list->GetDictionary(index, &dict))
     return false;
-  if (dict->size() != 2u)
+  if (dict->size() != 3u)
     return false;
   std::string url;
   if (!dict->GetString("url", &url))
@@ -32,6 +33,11 @@ bool ListEntryMatches(ListValue* list,
     return false;
   if (final_status != NameFromFinalStatus(expected_final_status))
     return false;
+  std::string end_time;
+  if (!dict->GetString("end_time", &end_time))
+    return false;
+  if (end_time != expected_end_time)
+    return false;
   return true;
 }
 
@@ -48,40 +54,54 @@ TEST(PrerenderHistoryTest, GetAsValue)  {
   ASSERT_TRUE(entry_value->GetAsList(&entry_list));
   EXPECT_TRUE(entry_list->empty());
 
+  // Base time used for all events.  Each event is given a time 1 millisecond
+  // after that of the previous one.
+  base::Time epoch_start = base::Time::UnixEpoch();
+
   // Add a single entry and make sure that it matches up.
   const char* const kFirstUrl = "http://www.alpha.com/";
   const FinalStatus kFirstFinalStatus = FINAL_STATUS_USED;
-  PrerenderHistory::Entry entry_first(GURL(kFirstUrl), kFirstFinalStatus);
+  PrerenderHistory::Entry entry_first(GURL(kFirstUrl), kFirstFinalStatus,
+                                      epoch_start);
   history.AddEntry(entry_first);
   entry_value.reset(history.GetEntriesAsValue());
   ASSERT_TRUE(entry_value.get() != NULL);
   ASSERT_TRUE(entry_value->GetAsList(&entry_list));
   EXPECT_EQ(1u, entry_list->GetSize());
-  EXPECT_TRUE(ListEntryMatches(entry_list, 0u, kFirstUrl, kFirstFinalStatus));
+  EXPECT_TRUE(ListEntryMatches(
+                  entry_list, 0u, kFirstUrl, kFirstFinalStatus, "0"));
 
   // Add a second entry and make sure both first and second appear.
   const char* const kSecondUrl = "http://www.beta.com/";
   const FinalStatus kSecondFinalStatus = FINAL_STATUS_INVALID_HTTP_METHOD;
-  PrerenderHistory::Entry entry_second(GURL(kSecondUrl), kSecondFinalStatus);
+  PrerenderHistory::Entry entry_second(
+      GURL(kSecondUrl), kSecondFinalStatus,
+      epoch_start + base::TimeDelta::FromMilliseconds(1));
   history.AddEntry(entry_second);
   entry_value.reset(history.GetEntriesAsValue());
   ASSERT_TRUE(entry_value.get() != NULL);
   ASSERT_TRUE(entry_value->GetAsList(&entry_list));
   EXPECT_EQ(2u, entry_list->GetSize());
-  EXPECT_TRUE(ListEntryMatches(entry_list, 0u, kSecondUrl, kSecondFinalStatus));
-  EXPECT_TRUE(ListEntryMatches(entry_list, 1u, kFirstUrl, kFirstFinalStatus));
+  EXPECT_TRUE(ListEntryMatches(
+                  entry_list, 0u, kSecondUrl, kSecondFinalStatus, "1"));
+  EXPECT_TRUE(ListEntryMatches(
+                  entry_list, 1u, kFirstUrl, kFirstFinalStatus, "0"));
 
   // Add a third entry and make sure that the first one drops off.
   const char* const kThirdUrl = "http://www.gamma.com/";
   const FinalStatus kThirdFinalStatus = FINAL_STATUS_AUTH_NEEDED;
-  PrerenderHistory::Entry entry_third(GURL(kThirdUrl), kThirdFinalStatus);
+  PrerenderHistory::Entry entry_third(
+      GURL(kThirdUrl), kThirdFinalStatus,
+      epoch_start + base::TimeDelta::FromMilliseconds(2));
   history.AddEntry(entry_third);
   entry_value.reset(history.GetEntriesAsValue());
   ASSERT_TRUE(entry_value.get() != NULL);
   ASSERT_TRUE(entry_value->GetAsList(&entry_list));
   EXPECT_EQ(2u, entry_list->GetSize());
-  EXPECT_TRUE(ListEntryMatches(entry_list, 0u, kThirdUrl, kThirdFinalStatus));
-  EXPECT_TRUE(ListEntryMatches(entry_list, 1u, kSecondUrl, kSecondFinalStatus));
+  EXPECT_TRUE(ListEntryMatches(
+                  entry_list, 0u, kThirdUrl, kThirdFinalStatus, "2"));
+  EXPECT_TRUE(ListEntryMatches(
+                  entry_list, 1u, kSecondUrl, kSecondFinalStatus, "1"));
 
   // Make sure clearing history acts as expected.
   history.Clear();
diff --git a/chrome/browser/prerender/prerender_manager.cc b/chrome/browser/prerender/prerender_manager.cc
index 9d79e4a..c2f0e00 100644
--- a/chrome/browser/prerender/prerender_manager.cc
+++ b/chrome/browser/prerender/prerender_manager.cc
@@ -993,6 +993,7 @@ Value* PrerenderManager::GetAsValue() const {
   DictionaryValue* dict_value = new DictionaryValue();
   dict_value->Set("history", prerender_history_->GetEntriesAsValue());
   dict_value->Set("active", GetActivePrerendersAsValue());
+  dict_value->SetBoolean("enabled", enabled_);
   return dict_value;
 }
 
@@ -1022,7 +1023,8 @@ Value* PrerenderManager::GetActivePrerendersAsValue() const {
 
 void PrerenderManager::AddToHistory(PrerenderContents* contents) {
   PrerenderHistory::Entry entry(contents->prerender_url(),
-                                contents->final_status());
+                                contents->final_status(),
+                                base::Time::Now());
   prerender_history_->AddEntry(entry);
 }
 
diff --git a/chrome/browser/resources/net_internals/index.html b/chrome/browser/resources/net_internals/index.html
index c1740c6..a0a185f 100644
--- a/chrome/browser/resources/net_internals/index.html
+++ b/chrome/browser/resources/net_internals/index.html
@@ -215,6 +215,9 @@ found in the LICENSE file.
     </div>
     <div id=prerenderTabContent>
       <h4>Prerender</h4>
+      <ul>
+        <li>Prerender Enabled: <span id=prerenderEnabledSpan></span></li>
+      </ul>
       <p>
         Active Prerender Pages
         <div id=prerenderActiveDiv>
diff --git a/chrome/browser/resources/net_internals/main.css b/chrome/browser/resources/net_internals/main.css
index c67e1e7..c4c6b98 100644
--- a/chrome/browser/resources/net_internals/main.css
+++ b/chrome/browser/resources/net_internals/main.css
@@ -219,7 +219,9 @@ body {
 #serviceProvidersTabContent,
 #testTabContent,
 #hstsTabContent,
-#httpThrottlingTabContent {
+#httpThrottlingTabContent,
+#prerenderTabContent,
+#logsTabContent {
   overflow: auto;
   padding: 10px;
 }
diff --git a/chrome/browser/resources/net_internals/main.js b/chrome/browser/resources/net_internals/main.js
index a523383..8333761 100644
--- a/chrome/browser/resources/net_internals/main.js
+++ b/chrome/browser/resources/net_internals/main.js
@@ -135,8 +135,10 @@ function onLoaded() {
                             'logsRefreshBtn');
   }
 
-  var prerenderView = new PrerenderView(
-      'prerenderTabContent', 'prerenderHistoryDiv', 'prerenderActiveDiv');
+  var prerenderView = new PrerenderView('prerenderTabContent',
+                                        'prerenderEnabledSpan',
+                                        'prerenderHistoryDiv',
+                                        'prerenderActiveDiv');
 
   // Create a view which lets you tab between the different sub-views.
   var categoryTabSwitcher = new TabSwitcherView('categoryTabHandles');
diff --git a/chrome/browser/resources/net_internals/prerenderview.js b/chrome/browser/resources/net_internals/prerenderview.js
index 653e584..3888653 100644
--- a/chrome/browser/resources/net_internals/prerenderview.js
+++ b/chrome/browser/resources/net_internals/prerenderview.js
@@ -6,9 +6,11 @@
  * This view displays information related to Prerendering.
  * @constructor
  */
-function PrerenderView(mainBoxId, prerenderHistoryDivId, prerenderActiveDivId) {
+function PrerenderView(mainBoxId, prerenderEnabledSpanId, prerenderHistoryDivId,
+                       prerenderActiveDivId) {
   DivView.call(this, mainBoxId);
   g_browser.addPrerenderInfoObserver(this);
+  this.prerenderEnabledSpan_ = document.getElementById(prerenderEnabledSpanId);
   this.prerenderHistoryDiv_ = document.getElementById(prerenderHistoryDivId);
   this.prerenderActiveDiv_ = document.getElementById(prerenderActiveDivId);
 }
@@ -19,22 +21,24 @@ function IsValidPrerenderInfo(prerenderInfo) {
   if (prerenderInfo == null) {
     return false;
   }
-  if (!'history' in prerenderInfo) {
-    return false;
-  }
-  if (!'active' in prerenderInfo) {
+  if (!('history' in prerenderInfo) ||
+      !('active' in prerenderInfo) ||
+      !('enabled' in prerenderInfo)) {
     return false;
   }
   return true;
 }
 
 PrerenderView.prototype.onPrerenderInfoChanged = function(prerenderInfo) {
+  this.prerenderEnabledSpan_.innerText = '';
   this.prerenderHistoryDiv_.innerHTML = '';
   this.prerenderActiveDiv_.innerHTML = '';
   if (!IsValidPrerenderInfo(prerenderInfo)) {
     return;
   }
 
+  this.prerenderEnabledSpan_.innerText = prerenderInfo.enabled.toString();
+
   var tabPrinter = PrerenderView.createHistoryTablePrinter(
       prerenderInfo.history);
   tabPrinter.toHTML(this.prerenderHistoryDiv_, 'styledTable');
@@ -48,12 +52,16 @@ PrerenderView.createHistoryTablePrinter = function(prerenderHistory) {
   var tablePrinter = new TablePrinter();
   tablePrinter.addHeaderCell('URL');
   tablePrinter.addHeaderCell('Final Status');
+  tablePrinter.addHeaderCell('Time');
 
   for (var i = 0; i < prerenderHistory.length; i++) {
     var historyEntry = prerenderHistory[i];
     tablePrinter.addRow();
     tablePrinter.addCell(historyEntry.url);
     tablePrinter.addCell(historyEntry.final_status);
+
+    var date = new Date(parseInt(historyEntry.end_time));
+    tablePrinter.addCell(date.toLocaleString());
   }
   return tablePrinter;
 };
diff --git a/chrome/browser/ui/webui/net_internals_ui.cc b/chrome/browser/ui/webui/net_internals_ui.cc
index 52fe458..9579dbe 100644
--- a/chrome/browser/ui/webui/net_internals_ui.cc
+++ b/chrome/browser/ui/webui/net_internals_ui.cc
@@ -694,14 +694,14 @@ void NetInternalsMessageHandler::OnEnableHttpThrottling(const ListValue* list) {
 void NetInternalsMessageHandler::OnGetPrerenderInfo(const ListValue* list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  Value* value = NULL;
+  scoped_ptr<Value> value;
   prerender::PrerenderManager* prerender_manager = prerender_manager_.get();
   if (!prerender_manager) {
-    value = new ListValue();
+    value.reset(new DictionaryValue());
   } else {
-    value = prerender_manager->GetAsValue();
+    value.reset(prerender_manager->GetAsValue());
   }
-  CallJavascriptFunction(L"g_browser.receivedPrerenderInfo", value);
+  CallJavascriptFunction(L"g_browser.receivedPrerenderInfo", value.get());
 }