Display more information at chrome://net-internals/#spdy

In particular, list the mapping from host:port to port:alternate-protocol 
and the global spdy configuration state.

BUG=none
TEST=chrome://net-internals/#spdy

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

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

5 files changed, 230 insertions, 2 deletions

diff --git a/chrome/browser/dom_ui/net_internals_ui.cc b/chrome/browser/dom_ui/net_internals_ui.cc
index 00e4ce3..7fb05a6 100644
--- a/chrome/browser/dom_ui/net_internals_ui.cc
+++ b/chrome/browser/dom_ui/net_internals_ui.cc
@@ -44,7 +44,9 @@
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/disk_cache/disk_cache.h"
+#include "net/http/http_alternate_protocols.h"
 #include "net/http/http_cache.h"
+#include "net/http/http_stream_factory.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #include "net/proxy/proxy_service.h"
@@ -256,6 +258,8 @@ class NetInternalsMessageHandler::IOThreadImpl
   void OnGetHttpCacheInfo(const ListValue* list);
   void OnGetSocketPoolInfo(const ListValue* list);
   void OnGetSpdySessionInfo(const ListValue* list);
+  void OnGetSpdyStatus(const ListValue* list);
+  void OnGetSpdyAlternateProtocolMappings(const ListValue* list);
 #ifdef OS_WIN
   void OnGetServiceProviders(const ListValue* list);
 #endif
@@ -511,6 +515,13 @@ void NetInternalsMessageHandler::RegisterMessages() {
   dom_ui_->RegisterMessageCallback(
       "getSpdySessionInfo",
       proxy_->CreateCallback(&IOThreadImpl::OnGetSpdySessionInfo));
+  dom_ui_->RegisterMessageCallback(
+      "getSpdyStatus",
+      proxy_->CreateCallback(&IOThreadImpl::OnGetSpdyStatus));
+  dom_ui_->RegisterMessageCallback(
+      "getSpdyAlternateProtocolMappings",
+      proxy_->CreateCallback(
+          &IOThreadImpl::OnGetSpdyAlternateProtocolMappings));
 #ifdef OS_WIN
   dom_ui_->RegisterMessageCallback(
       "getServiceProviders",
@@ -991,6 +1002,57 @@ void NetInternalsMessageHandler::IOThreadImpl::OnGetSpdySessionInfo(
   CallJavascriptFunction(L"g_browser.receivedSpdySessionInfo", spdy_info);
 }
 
+void NetInternalsMessageHandler::IOThreadImpl::OnGetSpdyStatus(
+    const ListValue* list) {
+  DictionaryValue* status_dict = new DictionaryValue();
+
+  status_dict->Set("spdy_enabled",
+                   Value::CreateBooleanValue(
+                       net::HttpStreamFactory::spdy_enabled()));
+  status_dict->Set("use_alternate_protocols",
+                   Value::CreateBooleanValue(
+                       net::HttpStreamFactory::use_alternate_protocols()));
+  status_dict->Set("force_spdy_over_ssl",
+                   Value::CreateBooleanValue(
+                       net::HttpStreamFactory::force_spdy_over_ssl()));
+  status_dict->Set("force_spdy_always",
+                   Value::CreateBooleanValue(
+                       net::HttpStreamFactory::force_spdy_always()));
+  status_dict->Set("next_protos",
+                   Value::CreateStringValue(
+                       *net::HttpStreamFactory::next_protos()));
+
+  CallJavascriptFunction(L"g_browser.receivedSpdyStatus", status_dict);
+}
+
+void
+NetInternalsMessageHandler::IOThreadImpl::OnGetSpdyAlternateProtocolMappings(
+    const ListValue* list) {
+  net::HttpNetworkSession* http_network_session =
+      GetHttpNetworkSession(context_getter_->GetURLRequestContext());
+
+  ListValue* dict_list = new ListValue();
+
+  if (http_network_session) {
+    const net::HttpAlternateProtocols& http_alternate_protocols =
+        http_network_session->alternate_protocols();
+    const net::HttpAlternateProtocols::ProtocolMap& map =
+        http_alternate_protocols.protocol_map();
+
+    for (net::HttpAlternateProtocols::ProtocolMap::const_iterator it =
+             map.begin();
+         it != map.end(); ++it) {
+      DictionaryValue* dict = new DictionaryValue();
+      dict->SetString("host_port_pair", it->first.ToString());
+      dict->SetString("alternate_protocol", it->second.ToString());
+      dict_list->Append(dict);
+    }
+  }
+
+  CallJavascriptFunction(L"g_browser.receivedSpdyAlternateProtocolMappings",
+                         dict_list);
+}
+
 #ifdef OS_WIN
 void NetInternalsMessageHandler::IOThreadImpl::OnGetServiceProviders(
     const ListValue* list) {
diff --git a/chrome/browser/resources/net_internals/dataview.js b/chrome/browser/resources/net_internals/dataview.js
index 5db47ff..7b7a47c 100644
--- a/chrome/browser/resources/net_internals/dataview.js
+++ b/chrome/browser/resources/net_internals/dataview.js
@@ -270,6 +270,20 @@ DataView.prototype.onUpdateAllCompleted = function(data) {
 
   text.push('');
   text.push('----------------------------------------------');
+  text.push(' SPDY Status');
+  text.push('----------------------------------------------');
+  text.push('');
+
+  text.push('SPDY Enabled: ' + data.spdyStatus.spdy_enabled);
+  text.push('Use Alternate Protocol: ' +
+      data.spdyStatus.use_alternate_protocols);
+  text.push('Force SPDY Always: ' + data.spdyStatus.force_spdy_always);
+  text.push('Force SPDY Over SSL: ' + data.spdyStatus.force_spdy_over_ssl);
+  text.push('Next Protocols: ' + data.spdyStatus.next_protos);
+
+
+  text.push('');
+  text.push('----------------------------------------------');
   text.push(' SPDY Sessions');
   text.push('----------------------------------------------');
   text.push('');
@@ -282,6 +296,22 @@ DataView.prototype.onUpdateAllCompleted = function(data) {
     text.push(spdyTablePrinter.toText(2));
   }
 
+  text.push('');
+  text.push('----------------------------------------------');
+  text.push(' Alternate Protocol Mappings');
+  text.push('----------------------------------------------');
+  text.push('');
+
+  if (data.spdyAlternateProtocolMappings == null ||
+      data.spdyAlternateProtocolMappings.length == 0) {
+    text.push('None');
+  } else {
+    var spdyTablePrinter =
+      SpdyView.createAlternateProtocolMappingsTablePrinter(
+          data.spdyAlternateProtocolMappings);
+    text.push(spdyTablePrinter.toText(2));
+  }
+
   if (g_browser.isPlatformWindows()) {
     text.push('');
     text.push('----------------------------------------------');
diff --git a/chrome/browser/resources/net_internals/index.html b/chrome/browser/resources/net_internals/index.html
index 0cbadb7..f3beb00 100644
--- a/chrome/browser/resources/net_internals/index.html
+++ b/chrome/browser/resources/net_internals/index.html
@@ -147,6 +147,15 @@ found in the LICENSE file.
       </p>
     </div>
     <div id=spdyTabContent>
+      <h4>SPDY Status</h4>
+      <ul>
+        <li>SPDY Enabled: <span id=spdyEnabledSpan>????</span></li>
+        <li>Use Alternate Protocol: <span id=spdyUseAlternateProtocolSpan>????</span></li>
+        <li>Force SPDY Always: <span id=spdyForceAlwaysSpan>????</span></li>
+        <li>Force SPDY Over SSL: <span id=spdyForceOverSslSpan>????</span></li>
+        <li>Next Protocols: <span id=spdyNextProtocolsSpan>????</span></li>
+      </ul>
+
       <h4>SPDY sessions</h4>
         <!-- Only one of these two are shown -->
         <span id=spdySessionNoneSpan>None</span>
@@ -157,6 +166,11 @@ found in the LICENSE file.
         <div id=spdySessionDiv>
         </div>
       </p>
+
+      <h4>Alternate Protocol Mappings</h4>
+      <p />
+        <div id=spdyAlternateProtocolMappingsDiv>
+        </div>
     </div>
     <div id=httpCacheTabContent>
       <h4>Entries</h4>
diff --git a/chrome/browser/resources/net_internals/main.js b/chrome/browser/resources/net_internals/main.js
index de8b43c..ed803c5 100644
--- a/chrome/browser/resources/net_internals/main.js
+++ b/chrome/browser/resources/net_internals/main.js
@@ -95,11 +95,16 @@ function onLoaded() {
                                     'socketPoolGroupsDiv');
 
   var spdyView = new SpdyView('spdyTabContent',
+                              'spdyEnabledSpan',
+                              'spdyUseAlternateProtocolSpan',
+                              'spdyForceAlwaysSpan',
+                              'spdyForceOverSslSpan',
+                              'spdyNextProtocolsSpan',
+                              'spdyAlternateProtocolMappingsDiv',
                               'spdySessionNoneSpan',
                               'spdySessionLinkSpan',
                               'spdySessionDiv');
 
-
   var serviceView;
   if (g_browser.isPlatformWindows()) {
     serviceView = new ServiceProvidersView('serviceProvidersTab',
@@ -184,6 +189,13 @@ function BrowserBridge() {
   this.pollableDataHelpers_.spdySessionInfo =
       new PollableDataHelper('onSpdySessionInfoChanged',
                              this.sendGetSpdySessionInfo.bind(this));
+  this.pollableDataHelpers_.spdyStatus =
+      new PollableDataHelper('onSpdyStatusChanged',
+                             this.sendGetSpdyStatus.bind(this));
+  this.pollableDataHelpers_.spdyAlternateProtocolMappings =
+      new PollableDataHelper('onSpdyAlternateProtocolMappingsChanged',
+                             this.sendGetSpdyAlternateProtocolMappings.bind(
+                                 this));
   if (this.isPlatformWindows()) {
     this.pollableDataHelpers_.serviceProviders =
         new PollableDataHelper('onServiceProvidersChanged',
@@ -301,6 +313,14 @@ BrowserBridge.prototype.sendGetSpdySessionInfo = function() {
   chrome.send('getSpdySessionInfo');
 };
 
+BrowserBridge.prototype.sendGetSpdyStatus = function() {
+  chrome.send('getSpdyStatus');
+};
+
+BrowserBridge.prototype.sendGetSpdyAlternateProtocolMappings = function() {
+  chrome.send('getSpdyAlternateProtocolMappings');
+};
+
 BrowserBridge.prototype.sendGetServiceProviders = function() {
   chrome.send('getServiceProviders');
 };
@@ -390,6 +410,16 @@ BrowserBridge.prototype.receivedSpdySessionInfo = function(spdySessionInfo) {
   this.pollableDataHelpers_.spdySessionInfo.update(spdySessionInfo);
 };
 
+BrowserBridge.prototype.receivedSpdyStatus = function(spdyStatus) {
+  this.pollableDataHelpers_.spdyStatus.update(spdyStatus);
+};
+
+BrowserBridge.prototype.receivedSpdyAlternateProtocolMappings =
+    function(spdyAlternateProtocolMappings) {
+  this.pollableDataHelpers_.spdyAlternateProtocolMappings.update(
+      spdyAlternateProtocolMappings);
+};
+
 BrowserBridge.prototype.receivedServiceProviders = function(serviceProviders) {
   this.pollableDataHelpers_.serviceProviders.update(serviceProviders);
 };
@@ -609,6 +639,28 @@ BrowserBridge.prototype.addSpdySessionInfoObserver = function(observer) {
 };
 
 /**
+ * Adds a listener of the SPDY status. |observer| will be called back
+ * when data is received, through:
+ *
+ *   observer.onSpdyStatusChanged(spdyStatus)
+ */
+BrowserBridge.prototype.addSpdyStatusObserver = function(observer) {
+  this.pollableDataHelpers_.spdyStatus.addObserver(observer);
+};
+
+/**
+ * Adds a listener of the AlternateProtocolMappings. |observer| will be called
+ * back when data is received, through:
+ *
+ *   observer.onSpdyAlternateProtocolMappingsChanged(
+ *       spdyAlternateProtocolMappings)
+ */
+BrowserBridge.prototype.addSpdyAlternateProtocolMappingsObserver =
+    function(observer) {
+  this.pollableDataHelpers_.spdyAlternateProtocolMappings.addObserver(observer);
+};
+
+/**
  * Adds a listener of the service providers info. |observer| will be called
  * back when data is received, through:
  *
diff --git a/chrome/browser/resources/net_internals/spdyview.js b/chrome/browser/resources/net_internals/spdyview.js
index e0d0bd2..d7abc5454 100644
--- a/chrome/browser/resources/net_internals/spdyview.js
+++ b/chrome/browser/resources/net_internals/spdyview.js
@@ -8,11 +8,27 @@
  *
  * @constructor
  */
-function SpdyView(mainBoxId, spdySessionNoneSpanId, spdySessionLinkSpanId,
+function SpdyView(mainBoxId, spdyEnabledSpanId,
+                  spdyUseAlternateProtocolSpanId,
+                  spdyForceAlwaysSpanId, spdyForceOverSslSpanId,
+                  spdyNextProtocolsSpanId, spdyAlternateProtocolMappingsDivId,
+                  spdySessionNoneSpanId, spdySessionLinkSpanId,
                   spdySessionDivId) {
   DivView.call(this, mainBoxId);
   g_browser.addSpdySessionInfoObserver(this);
+  g_browser.addSpdyStatusObserver(this);
+  g_browser.addSpdyAlternateProtocolMappingsObserver(this);
 
+  this.spdyEnabledSpan_ = document.getElementById(spdyEnabledSpanId);
+  this.spdyUseAlternateProtocolSpan_ =
+      document.getElementById(spdyUseAlternateProtocolSpanId);
+  this.spdyForceAlwaysSpan_ = document.getElementById(spdyForceAlwaysSpanId);
+  this.spdyForceOverSslSpan_ = document.getElementById(spdyForceOverSslSpanId);
+  this.spdyNextProtocolsSpan_ =
+      document.getElementById(spdyNextProtocolsSpanId);
+
+  this.spdyAlternateProtocolMappingsDiv_ =
+      document.getElementById(spdyAlternateProtocolMappingsDivId);
   this.spdySessionNoneSpan_ = document.getElementById(spdySessionNoneSpanId);
   this.spdySessionLinkSpan_ = document.getElementById(spdySessionLinkSpanId);
   this.spdySessionDiv_ = document.getElementById(spdySessionDivId);
@@ -36,6 +52,39 @@ SpdyView.prototype.onSpdySessionInfoChanged = function(spdySessionInfo) {
 
   var tablePrinter = SpdyView.createSessionTablePrinter(spdySessionInfo);
   tablePrinter.toHTML(this.spdySessionDiv_, 'styledTable');
+
+};
+
+/**
+ * Displays information on the global SPDY status.
+ */
+SpdyView.prototype.onSpdyStatusChanged = function(spdyStatus) {
+  this.spdyEnabledSpan_.innerText = spdyStatus.spdy_enabled;
+  this.spdyUseAlternateProtocolSpan_.innerText =
+      spdyStatus.use_alternate_protocols;
+  this.spdyForceAlwaysSpan_.innerText = spdyStatus.force_spdy_always;
+  this.spdyForceOverSslSpan_.innerText = spdyStatus.force_spdy_over_ssl;
+  this.spdyNextProtocolsSpan_.innerText = spdyStatus.next_protos;
+}
+
+/**
+ * If |spdyAlternateProtocolMappings| is not empty, displays a single table
+ * with information on each alternate protocol enabled server.  Otherwise,
+ * displays "None".
+ */
+SpdyView.prototype.onSpdyAlternateProtocolMappingsChanged =
+    function(spdyAlternateProtocolMappings) {
+
+  this.spdyAlternateProtocolMappingsDiv_.innerHTML = '';
+
+  if (spdyAlternateProtocolMappings != null &&
+      spdyAlternateProtocolMappings.length > 0) {
+    var tabPrinter = SpdyView.createAlternateProtocolMappingsTablePrinter(
+            spdyAlternateProtocolMappings);
+    tabPrinter.toHTML(this.spdyAlternateProtocolMappingsDiv_, 'styledTable');
+  } else {
+    this.spdyAlternateProtocolMappingsDiv_.innerHTML = 'None';
+  }
 };
 
 /**
@@ -85,3 +134,24 @@ SpdyView.createSessionTablePrinter = function(spdySessions) {
   return tablePrinter;
 };
 
+
+/**
+ * Creates a table printer to print out the list of alternate protocol
+ * mappings.
+ */
+SpdyView.createAlternateProtocolMappingsTablePrinter =
+    function(spdyAlternateProtocolMappings) {
+  var tablePrinter = new TablePrinter();
+  tablePrinter.addHeaderCell('Host');
+  tablePrinter.addHeaderCell('Alternate Protocol');
+
+  for (var i = 0; i < spdyAlternateProtocolMappings.length; i++) {
+    var entry = spdyAlternateProtocolMappings[i];
+    tablePrinter.addRow();
+
+    tablePrinter.addCell(entry.host_port_pair);
+    tablePrinter.addCell(entry.alternate_protocol);
+  }
+  return tablePrinter;
+};
+