- Add a priority field to QuicCryptoServerConfig configs and used it as

net/quic/crypto/quic_crypto_server_config_test.cc

 // Copyright 2013 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 "net/quic/crypto/quic_crypto_server_config.h"
 
 #include <stdarg.h>
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
@@ skipping 133 matching lines @@
     server_config_->SelectNewPrimaryConfig(
         QuicWallTime::FromUNIXSeconds(seconds));
   }
 
  private:
   const QuicCryptoServerConfig* server_config_;
 };
 
 class TestStrikeRegisterClient : public StrikeRegisterClient {
  public:
-  TestStrikeRegisterClient(QuicCryptoServerConfig* config, string orbit)
-      : config_(config), orbit_(orbit), orbit_called_(false) {}
+  explicit TestStrikeRegisterClient(QuicCryptoServerConfig* config)
+      : config_(config), is_known_orbit_called_(false) {}
 
-  virtual string orbit() OVERRIDE {
+  virtual bool IsKnownOrbit(StringPiece orbit) const OVERRIDE {
     // Ensure that the strike register client lock is not held.
     QuicCryptoServerConfigPeer peer(config_);
     base::Lock* m = peer.GetStrikeRegisterClientLock();
     // In Chromium, we will dead lock if the lock is held by the current thread.
     // Chromium doesn't have AssertNotHeld API call.
     // m->AssertNotHeld();
     base::AutoLock lock(*m);
 
-    orbit_called_ = true;
-    return orbit_;
+    is_known_orbit_called_ = true;
+    return true;
   }
 
   virtual void VerifyNonceIsValidAndUnique(
       StringPiece nonce,
       QuicWallTime now,
       ResultCallback* cb) OVERRIDE {
     LOG(FATAL) << "Not implemented";
   }
 
-  bool orbit_called() { return orbit_called_; }
+  bool is_known_orbit_called() { return is_known_orbit_called_; }
 
  private:
   QuicCryptoServerConfig* config_;
-  string orbit_;
-  bool orbit_called_;
+  mutable bool is_known_orbit_called_;
 };
 
 TEST(QuicCryptoServerConfigTest, ServerConfig) {
   QuicRandom* rand = QuicRandom::GetInstance();
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand);
   MockClock clock;
 
   scoped_ptr<CryptoHandshakeMessage>(
       server.AddDefaultConfig(rand, &clock,
                               QuicCryptoServerConfig::ConfigOptions()));
 }
 
 TEST(QuicCryptoServerConfigTest, GetOrbitIsCalledWithoutTheStrikeRegisterLock) {
   QuicRandom* rand = QuicRandom::GetInstance();
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand);
   MockClock clock;
 
-  const char kOrbit[] = "12345678";
-
   TestStrikeRegisterClient* strike_register =
-      new TestStrikeRegisterClient(&server, kOrbit);
+      new TestStrikeRegisterClient(&server);
   server.SetStrikeRegisterClient(strike_register);
 
   QuicCryptoServerConfig::ConfigOptions options;
-  options.orbit = kOrbit;
   scoped_ptr<CryptoHandshakeMessage>(
       server.AddDefaultConfig(rand, &clock, options));
-  EXPECT_TRUE(strike_register->orbit_called());
+  EXPECT_TRUE(strike_register->is_known_orbit_called());
 }
 
 TEST(QuicCryptoServerConfigTest, SourceAddressTokens) {
   QuicRandom* rand = QuicRandom::GetInstance();
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand);
   IPAddressNumber ip;
   CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
   IPEndPoint ip4 = IPEndPoint(ip, 1);
   CHECK(ParseIPLiteralToNumber("2001:db8:0::42", &ip));
   IPEndPoint ip6 = IPEndPoint(ip, 2);
@@ skipping 30 matching lines @@
 
   // SetConfigs constructs suitable config protobufs and calls SetConfigs on
   // |config_|. The arguments are given as NULL-terminated pairs. The first of
   // each pair is the server config ID of a Config. The second is the
   // |primary_time| of that Config, given in epoch seconds. (Although note
   // that, in these tests, time is set to 1000 seconds since the epoch.) For
   // example:
   //   SetConfigs(NULL);  // calls |config_.SetConfigs| with no protobufs.
   //
   //   // Calls |config_.SetConfigs| with two protobufs: one for a Config with
-  //   // a |primary_time| of 900, and another with a |primary_time| of 1000.
+  //   // a |primary_time| of 900 and priority 1, and another with
+  //   // a |primary_time| of 1000 and priority 2.
+
   //   CheckConfigs(
-  //     "id1", 900,
-  //     "id2", 1000,
+  //     "id1", 900, 1,
+  //     "id2", 1000, 2,
   //     NULL);
   //
   // If the server config id starts with "INVALID" then the generated protobuf
   // will be invalid.
   void SetConfigs(const char* server_config_id1, ...) {
+    const char kOrbit[] = "12345678";
+
     va_list ap;
     va_start(ap, server_config_id1);
     bool has_invalid = false;
+    bool is_empty = true;
 
     vector<QuicServerConfigProtobuf*> protobufs;
     bool first = true;
     for (;;) {
       const char* server_config_id;
       if (first) {
         server_config_id = server_config_id1;
         first = false;
       } else {
         server_config_id = va_arg(ap, const char*);
       }
 
       if (!server_config_id) {
         break;
       }
 
+      is_empty = false;
       int primary_time = va_arg(ap, int);
+      int priority = va_arg(ap, int);
 
       QuicCryptoServerConfig::ConfigOptions options;
       options.id = server_config_id;
+      options.orbit = kOrbit;
       QuicServerConfigProtobuf* protobuf(
-          QuicCryptoServerConfig::DefaultConfig(rand_, &clock_, options));
+          QuicCryptoServerConfig::GenerateConfig(rand_, &clock_, options));
       protobuf->set_primary_time(primary_time);
+      protobuf->set_priority(priority);
       if (string(server_config_id).find("INVALID") == 0) {
         protobuf->clear_key();
         has_invalid = true;
       }
       protobufs.push_back(protobuf);
     }
 
-    ASSERT_EQ(!has_invalid, config_.SetConfigs(protobufs, clock_.WallNow()));
+    ASSERT_EQ(!has_invalid && !is_empty,
+              config_.SetConfigs(protobufs, clock_.WallNow()));
     STLDeleteElements(&protobufs);
   }
 
  protected:
   QuicRandom* const rand_;
   MockClock clock_;
   QuicCryptoServerConfig config_;
   QuicCryptoServerConfigPeer test_peer_;
 };
 
 TEST_F(CryptoServerConfigsTest, NoConfigs) {
   test_peer_.CheckConfigs(NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, MakePrimaryFirst) {
   // Make sure that "b" is primary even though "a" comes first.
-  SetConfigs("a", 1100,
-             "b", 900,
+  SetConfigs("a", 1100, 1,
+             "b", 900, 1,
              NULL);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, MakePrimarySecond) {
   // Make sure that a remains primary after b is added.
-  SetConfigs("a", 900,
-             "b", 1100,
+  SetConfigs("a", 900, 1,
+             "b", 1100, 1,
              NULL);
   test_peer_.CheckConfigs(
       "a", true,
       "b", false,
       NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, Delete) {
   // Ensure that configs get deleted when removed.
-  SetConfigs("a", 800,
-             "b", 900,
-             "c", 1100,
+  SetConfigs("a", 800, 1,
+             "b", 900, 1,
+             "c", 1100, 1,
              NULL);
-  SetConfigs("b", 900,
-             "c", 1100,
+  test_peer_.CheckConfigs(
+      "a", false,
+      "b", true,
+      "c", false,
+      NULL);
+  SetConfigs("b", 900, 1,
+             "c", 1100, 1,
              NULL);
   test_peer_.CheckConfigs(
       "b", true,
       "c", false,
       NULL);
 }
 
-TEST_F(CryptoServerConfigsTest, DontDeletePrimary) {
-  // Ensure that the primary config isn't deleted when removed.
-  SetConfigs("a", 800,
-             "b", 900,
-             "c", 1100,
-             NULL);
-  SetConfigs("a", 800,
-             "c", 1100,
+TEST_F(CryptoServerConfigsTest, DeletePrimary) {
+  // Ensure that deleting the primary config works.
+  SetConfigs("a", 800, 1,
+             "b", 900, 1,
+             "c", 1100, 1,
              NULL);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       "c", false,
       NULL);
+  SetConfigs("a", 800, 1,
+             "c", 1100, 1,
+             NULL);
+  test_peer_.CheckConfigs(
+      "a", true,
+      "c", false,
+      NULL);
+}
+
+TEST_F(CryptoServerConfigsTest, FailIfDeletingAllConfigs) {
+  // Ensure that configs get deleted when removed.
+  SetConfigs("a", 800, 1,
+             "b", 900, 1,
+             NULL);
+  test_peer_.CheckConfigs(
+      "a", false,
+      "b", true,
+      NULL);
+  SetConfigs(NULL);
+  // Config change is rejected, still using old configs.
+  test_peer_.CheckConfigs(
+      "a", false,
+      "b", true,
+      NULL);
+}
+
+TEST_F(CryptoServerConfigsTest, ChangePrimaryTime) {
+  // Check that updates to primary time get picked up.
+  SetConfigs("a", 400, 1,
+             "b", 800, 1,
+             "c", 1200, 1,
+             NULL);
+  test_peer_.SelectNewPrimaryConfig(500);
+  test_peer_.CheckConfigs(
+      "a", true,
+      "b", false,
+      "c", false,
+      NULL);
+  SetConfigs("a", 1200, 1,
+             "b", 800, 1,
+             "c", 400, 1,
+             NULL);
+  test_peer_.SelectNewPrimaryConfig(500);
+  test_peer_.CheckConfigs(
+      "a", false,
+      "b", false,
+      "c", true,
+      NULL);
+}
+
+TEST_F(CryptoServerConfigsTest, AllConfigsInThePast) {
+  // Check that the most recent config is selected.
+  SetConfigs("a", 400, 1,
+             "b", 800, 1,
+             "c", 1200, 1,
+             NULL);
+  test_peer_.SelectNewPrimaryConfig(1500);
+  test_peer_.CheckConfigs(
+      "a", false,
+      "b", false,
+      "c", true,
+      NULL);
+}
+
+TEST_F(CryptoServerConfigsTest, AllConfigsInTheFuture) {
+  // Check that the first config is selected.
+  SetConfigs("a", 400, 1,
+             "b", 800, 1,
+             "c", 1200, 1,
+             NULL);
+  test_peer_.SelectNewPrimaryConfig(100);
+  test_peer_.CheckConfigs(
+      "a", true,
+      "b", false,
+      "c", false,
+      NULL);
+}
+
+TEST_F(CryptoServerConfigsTest, SortByPriority) {
+  // Check that priority is used to decide on a primary config when
+  // configs have the same primary time.
+  SetConfigs("a", 900, 1,
+             "b", 900, 2,
+             "c", 900, 3,
+             NULL);
+  test_peer_.CheckConfigs(
+      "a", true,
+      "b", false,
+      "c", false,
+      NULL);
+  test_peer_.SelectNewPrimaryConfig(800);
+  test_peer_.CheckConfigs(
+      "a", true,
+      "b", false,
+      "c", false,
+      NULL);
+  test_peer_.SelectNewPrimaryConfig(1000);
+  test_peer_.CheckConfigs(
+      "a", true,
+      "b", false,
+      "c", false,
+      NULL);
+
+  // Change priorities and expect sort order to change.
+  SetConfigs("a", 900, 2,
+             "b", 900, 1,
+             "c", 900, 0,
+             NULL);
+  test_peer_.CheckConfigs(
+      "a", false,
+      "b", false,
+      "c", true,
+      NULL);
+  test_peer_.SelectNewPrimaryConfig(800);
+  test_peer_.CheckConfigs(
+      "a", false,
+      "b", false,
+      "c", true,
+      NULL);
+  test_peer_.SelectNewPrimaryConfig(1000);
+  test_peer_.CheckConfigs(
+      "a", false,
+      "b", false,
+      "c", true,
+      NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, AdvancePrimary) {
   // Check that a new primary config is enabled at the right time.
-  SetConfigs("a", 900,
-             "b", 1100,
+  SetConfigs("a", 900, 1,
+             "b", 1100, 1,
              NULL);
   test_peer_.SelectNewPrimaryConfig(1000);
   test_peer_.CheckConfigs(
       "a", true,
       "b", false,
       NULL);
   test_peer_.SelectNewPrimaryConfig(1101);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, InvalidConfigs) {
   // Ensure that invalid configs don't change anything.
-  SetConfigs("a", 800,
-             "b", 900,
-             "c", 1100,
+  SetConfigs("a", 800, 1,
+             "b", 900, 1,
+             "c", 1100, 1,
              NULL);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       "c", false,
       NULL);
-  SetConfigs("a", 800,
-             "c", 1100,
-             "INVALID1", 1000,
+  SetConfigs("a", 800, 1,
+             "c", 1100, 1,
+             "INVALID1", 1000, 1,
              NULL);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       "c", false,
       NULL);
 }
 
 }  // namespace test
 }  // namespace net