Implement SecurityHandler to send the lock icon status to DevTools.

content/browser/devtools/protocol/security_handler.cc

+// Copyright 2014 The Chromium Authors. All rights reserved.

[estark, 2015/06/04 01:09:15]

copyright should be 2015

[lgarron, 2015/06/05 01:29:18]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <string>
+
+#include "base/logging.h"
+#include "content/browser/devtools/protocol/security_handler.h"

[estark, 2015/06/04 01:09:14]

This should be at the top of the #include list.

+
+namespace content {
+namespace devtools {
+namespace security {
+
+typedef DevToolsProtocolClient::Response Response;
+
+SecurityHandler::SecurityHandler() : enabled_(false) {
+}
+
+SecurityHandler::~SecurityHandler() {
+}
+
+void SecurityHandler::SetClient(scoped_ptr<Client> client) {
+  client_.swap(client);
+}
+
+void SecurityHandler::SecurityStyleChanged(SecurityStyle security_style) {
+  if (!enabled_)
+    return;
+
+  const std::string security_state =
+      SecurityStyleToProtocolSecurityState(security_style);
+  client_->SecurityStateChanged(

[estark, 2015/06/05 00:59:10]

Ah, just realized this won't build without the protocol.json patch, right? So I
guess we need to take this bit out for now (probably with a TODO in its place),
then add it back in once the protocol.json changes are rolled in. (And at that
point it'll probably be a good time to write a test too, since there's not much
to test once we take this bit out.)

[lgarron, 2015/06/06 00:57:40]

I think it would make more sense to land protocol.json before this CL, then.

+      SecurityStateChangedParams::Create()->set_security_state(security_state));
+}
+
+Response SecurityHandler::Enable() {
+  enabled_ = true;
+  return Response::OK();
+}
+
+Response SecurityHandler::Disable() {
+  enabled_ = false;
+  return Response::FallThrough();

[estark, 2015/06/04 01:09:14]

I think this should be Response::OK() like Enable() above. When I was playing
around it seemed that Response::FallThrough() would pass through and try to find
a renderer handler for the command, which we don't have in this case.

[lgarron, 2015/06/05 01:29:18]

Makes sense (I trust you on verifying that's what it does).
Done.

+}
+
+std::string SecurityHandler::SecurityStyleToProtocolSecurityState(
+    SecurityStyle security_style) {
+  switch (security_style) {
+    case SECURITY_STYLE_UNKNOWN:
+      return "UNKNOWN";

[estark, 2015/06/04 01:09:15]

It looks like constants for these enum values will get generated (see e.g.
https://code.google.com/p/chromium/codesearch#chromium/src/out/Debug/gen/cont...).
So maybe put a TODO here to come back and use the constants once the
protocol.json changes have been rolled in?

[lgarron, 2015/06/05 01:29:18]

Done.

+    case SECURITY_STYLE_UNAUTHENTICATED:
+      return "HTTP";
+    case SECURITY_STYLE_AUTHENTICATION_BROKEN:
+      return "INSECURE";
+    case SECURITY_STYLE_WARNING:
+      return "WARNING";
+    case SECURITY_STYLE_AUTHENTICATED:
+      return "SECURE";
+    default:

[estark, 2015/06/04 01:09:14]

Same comment here that I put in the other CL; I prefer to leave off the default
cause and end with 'NOTREACHED(); return "UNKNOWN";' so that it'll fail to
compile if a SecurityStyle value isn't handled in this switch statement.

[pfeldman, 2015/06/04 09:28:35]

@estark: it is a good idea here, but don't do that when switching over the
generated enum literals. Otherwise two-sided patches become impossible.

[lgarron, 2015/06/05 01:29:18]

Good point. I'll leave it this way for now.

+      NOTREACHED();
+  }
+}
+
+}  // namespace security
+}  // namespace devtools
+}  // namespace content