diff --git a/godoc/static/godoc.html b/godoc/static/godoc.html
index ee6a3a6..c851c52 100644
--- a/godoc/static/godoc.html
+++ b/godoc/static/godoc.html
@@ -61,7 +61,6 @@
 <div class="container">
 
 {{with .Title}}
-  <div id="plusone"><g:plusone size="small" annotation="none"></g:plusone></div>
   <h1>{{html .}}</h1>
 {{end}}
 {{with .Subtitle}}
diff --git a/godoc/static/godocs.js b/godoc/static/godocs.js
index 81dd121..c4a61e0 100644
--- a/godoc/static/godocs.js
+++ b/godoc/static/godocs.js
@@ -232,15 +232,6 @@
     }
 }
 
-function addPlusButtons() {
-  var po = document.createElement('script');
-  po.type = 'text/javascript';
-  po.async = true;
-  po.src = 'https://apis.google.com/js/platform.js';
-  var s = document.getElementsByTagName('script')[0];
-  s.parentNode.insertBefore(po, s);
-}
-
 $(document).ready(function() {
   bindSearchEvents();
   generateTOC();
@@ -256,7 +247,6 @@
   setupTypeInfo();
   setupCallgraphs();
   toggleHash();
-  addPlusButtons();
 
   // godoc.html defines window.initFuncs in the <head> tag, and root.html and
   // codewalk.js push their on-page-ready functions to the list.
diff --git a/godoc/static/static.go b/godoc/static/static.go
index 53d58a5..30e63fb 100644
--- a/godoc/static/static.go
+++ b/godoc/static/static.go
@@ -306,14 +306,14 @@
 	</div>
 	<div class="expanded">
 		<p class="exampleHeading toggleButton">▾ <span class="text">Internal call graph</span></p>
-                <p>
-                  This viewer shows the portion of the internal call
-                  graph of this package that is reachable from this function.  
-                  See the <a href='#pkg-callgraph'>package's call
-                  graph</a> for more information.
-                </p>
-                <ul style="margin-left: 0.5in" id="callgraph-{{.Index}}" class="treeview"></ul>
-        </div>
+		<p>
+		  This viewer shows the portion of the internal call
+		  graph of this package that is reachable from this function.
+		  See the <a href='#pkg-callgraph'>package's call
+		  graph</a> for more information.
+		</p>
+		<ul style="margin-left: 0.5in" id="callgraph-{{.Index}}" class="treeview"></ul>
+	</div>
 </div>
 `,
 
@@ -530,7 +530,6 @@
 <div class="container">
 
 {{with .Title}}
-  <div id="plusone"><g:plusone size="small" annotation="none"></g:plusone></div>
   <h1>{{html .}}</h1>
 {{end}}
 {{with .Subtitle}}
@@ -806,15 +805,6 @@
     }
 }
 
-function addPlusButtons() {
-  var po = document.createElement('script');
-  po.type = 'text/javascript';
-  po.async = true;
-  po.src = 'https://apis.google.com/js/platform.js';
-  var s = document.getElementsByTagName('script')[0];
-  s.parentNode.insertBefore(po, s);
-}
-
 $(document).ready(function() {
   bindSearchEvents();
   generateTOC();
@@ -830,7 +820,6 @@
   setupTypeInfo();
   setupCallgraphs();
   toggleHash();
-  addPlusButtons();
 
   // godoc.html defines window.initFuncs in the <head> tag, and root.html and
   // codewalk.js push their on-page-ready functions to the list.
@@ -1111,7 +1100,7 @@
 	</div>
 	<div class="expanded">
 		<p class="exampleHeading toggleButton">▾ <span class="text">Implements</span></p>
-                <div style="margin-left: 1in" id='implements-{{.Index}}'>...</div>
+		<div style="margin-left: 1in" id='implements-{{.Index}}'>...</div>
 	</div>
 </div>
 `,
@@ -1502,7 +1491,7 @@
 	</div>
 	<div class="expanded">
 		<p class="exampleHeading toggleButton">▾ <span class="text">Method set</span></p>
-                <div style="margin-left: 1in" id='methodset-{{.Index}}'>...</div>
+		<div style="margin-left: 1in" id='methodset-{{.Index}}'>...</div>
 	</div>
 </div>
 `,
@@ -1533,9 +1522,9 @@
 -->
 {{with .PDoc}}
 	<script type='text/javascript'>
-        document.ANALYSIS_DATA = {{$.AnalysisData}};
-        document.CALLGRAPH = {{$.CallGraph}};
-        </script>
+	document.ANALYSIS_DATA = {{$.AnalysisData}};
+	document.CALLGRAPH = {{$.CallGraph}};
+	</script>
 
 	{{if $.IsMain}}
 		{{/* command documentation */}}
@@ -1639,35 +1628,34 @@
 		</div> <!-- .expanded -->
 		<div class="expanded">
 			<h2 class="toggleButton" title="Click to hide Internal Call Graph section">Internal call graph ▾</h2>
-                        <p>
-                          In the call graph viewer below, each node
-                          is a function belonging to this package
-                          and its children are the functions it
-                          calls&mdash;perhaps dynamically.
-                        </p>
-                        <p>
-                          The root nodes are the entry points of the
-                          package: functions that may be called from
-                          outside the package.  
-                          There may be non-exported or anonymous
-                          functions among them if they are called
-                          dynamically from another package.
-                        </p>
-                        <p>
-                          Click a node to visit that function's source code.
-                          From there you can visit its callers by
-                          clicking its declaring <code>func</code>
-                          token.
-                        </p>
-                        <p>
-                          Functions may be omitted if they were
-                          determined to be unreachable in the
-                          particular programs or tests that were
-                          analyzed.
-                        </p>
-                        <!-- Zero means show all package entry points. -->
-                        <ul style="margin-left: 0.5in" id="callgraph-0" class="treeview"></ul>
-                        </script>                        
+			<p>
+			  In the call graph viewer below, each node
+			  is a function belonging to this package
+			  and its children are the functions it
+			  calls&mdash;perhaps dynamically.
+			</p>
+			<p>
+			  The root nodes are the entry points of the
+			  package: functions that may be called from
+			  outside the package.
+			  There may be non-exported or anonymous
+			  functions among them if they are called
+			  dynamically from another package.
+			</p>
+			<p>
+			  Click a node to visit that function's source code.
+			  From there you can visit its callers by
+			  clicking its declaring <code>func</code>
+			  token.
+			</p>
+			<p>
+			  Functions may be omitted if they were
+			  determined to be unreachable in the
+			  particular programs or tests that were
+			  analyzed.
+			</p>
+			<!-- Zero means show all package entry points. -->
+			<ul style="margin-left: 0.5in" id="callgraph-0" class="treeview"></ul>
 		</div>
 		</div> <!-- #pkg-callgraph -->
 
@@ -1722,7 +1710,7 @@
 				<pre>{{node_html $ .Decl true}}</pre>
 				{{comment_html .Doc}}
 				{{example_html $ .Name}}
-			        {{callgraph_html $ "" .Name}}
+				{{callgraph_html $ "" .Name}}
 			{{end}}
 
 			{{range .Methods}}
@@ -1732,7 +1720,7 @@
 				{{comment_html .Doc}}
 				{{$name := printf "%s_%s" $tname .Name}}
 				{{example_html $ $name}}
-			        {{callgraph_html $ .Recv .Name}}
+				{{callgraph_html $ .Recv .Name}}
 			{{end}}
 		{{end}}
 	{{end}}
@@ -2638,23 +2626,23 @@
 	license that can be found in the LICENSE file.
 -->
 {{range $key, $val := .Idents}}
-        {{if $val}}
+	{{if $val}}
 		<h2 id="{{$key.Name}}">{{$key.Name}}</h2>
-                {{range $val}}
-	                {{$pkg_html := pkgLink .Path | html}}
+		{{range $val}}
+			{{$pkg_html := pkgLink .Path | html}}
 			{{if eq "Packages" $key.Name}}
-  	                	<a href="/{{$pkg_html}}">{{html .Path}}</a>
+				<a href="/{{$pkg_html}}">{{html .Path}}</a>
 			{{else}}
-		        	{{$doc_html := docLink .Path .Name| html}}
-  	                	<a href="/{{$pkg_html}}">{{html .Package}}</a>.<a href="{{$doc_html}}">{{.Name}}</a>
-                        {{end}}
-                        {{if .Doc}}
-                        	<p>{{comment_html .Doc}}</p>
-                        {{else}}
-                        	<p><em>No documentation available</em></p>
-                        {{end}}
-                {{end}}
-        {{end}}
+				{{$doc_html := docLink .Path .Name| html}}
+				<a href="/{{$pkg_html}}">{{html .Package}}</a>.<a href="{{$doc_html}}">{{.Name}}</a>
+			{{end}}
+			{{if .Doc}}
+				<p>{{comment_html .Doc}}</p>
+			{{else}}
+				<p><em>No documentation available</em></p>
+			{{end}}
+		{{end}}
+	{{end}}
 {{end}}
 `,
 
