Fix the secure proxy check state displayed on net-internals#bandwidth.

components/data_reduction_proxy/core/common/data_reduction_proxy_event_store_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_event_store.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 24 matching lines @@
         new DataReductionProxyEventCreator(event_store_.get()));
   }
 
   net::TestNetLogEntry GetSingleEntry() const {
     net::TestNetLogEntry::List entries;
     net_log_->GetEntries(&entries);
     EXPECT_EQ(1u, entries.size());
     return entries[0];
   }
 
+  net::TestNetLogEntry GetLatestEntry() const {
+    net::TestNetLogEntry::List entries;
+    net_log_->GetEntries(&entries);
+    return entries.back();
+  }
+
   DataReductionProxyEventStore* event_store() { return event_store_.get(); }
 
   DataReductionProxyEventCreator* event_creator() {
     return event_creator_.get();
   }
 
   net::TestNetLog* net_log() { return net_log_.get(); }
 
   const net::BoundNetLog& bound_net_log() {
     return bound_net_log_;
@@ skipping 95 matching lines @@
   event_creator()->EndSecureProxyCheck(bound_net_log(), 0, net::HTTP_OK, true);
   EXPECT_EQ(1u, event_count());
   EXPECT_EQ(1u, net_log()->GetSize());
   net::TestNetLogEntry entry = GetSingleEntry();
   EXPECT_EQ(net::NetLog::TYPE_DATA_REDUCTION_PROXY_CANARY_REQUEST,
             entry.type);
   EXPECT_EQ(DataReductionProxyEventStorageDelegate::CHECK_SUCCESS,
             secure_proxy_check_state());
 }
 
+TEST_F(DataReductionProxyEventStoreTest, TestEndSecureProxyCheckFailed) {
+  const struct {
+    const char* test_case;
+    int net_error;
+    int http_response_code;
+    bool secure_proxy_check_succeeded;
+    bool expected_proxy_check_succeeded;
+  } tests[] = {
+      {
+       "Succeeded", net::OK, net::HTTP_OK, true, true,
+      },
+      {
+       "Net failure", net::ERR_CONNECTION_RESET, -1, false, false,
+      },
+      {
+       "HTTP failure", net::OK, net::HTTP_NOT_FOUND, false, false,
+      },
+      {
+       "Bad content", net::OK, net::HTTP_OK, false, false,
+      },
+  };
+  size_t expected_event_count = 0;
+  EXPECT_EQ(expected_event_count, net_log()->GetSize());
+  EXPECT_EQ(expected_event_count++, event_count());
+  EXPECT_EQ(DataReductionProxyEventStorageDelegate::CHECK_UNKNOWN,
+            secure_proxy_check_state());
+  for (const auto& test : tests) {
+    event_creator()->EndSecureProxyCheck(bound_net_log(), test.net_error,
+                                         test.http_response_code,
+                                         test.secure_proxy_check_succeeded);
+    EXPECT_EQ(expected_event_count, net_log()->GetSize()) << test.test_case;
+    EXPECT_EQ(expected_event_count++, event_count()) << test.test_case;
+    net::TestNetLogEntry entry = GetLatestEntry();
+    EXPECT_EQ(net::NetLog::TYPE_DATA_REDUCTION_PROXY_CANARY_REQUEST, entry.type)
+        << test.test_case;
+    EXPECT_EQ(test.secure_proxy_check_succeeded
+                  ? DataReductionProxyEventStorageDelegate::CHECK_SUCCESS
+                  : DataReductionProxyEventStorageDelegate::CHECK_FAILED,
+              secure_proxy_check_state())
+        << test.test_case;
+  }
+}
+
 }  // namespace data_reduction_proxy