Do not persist HttpServerProperties to disk that often.

net/http/http_server_properties_impl.cc

 // Copyright (c) 2012 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/http/http_server_properties_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 391 matching lines @@
 
   if (alternative_service_info_vector.empty()) {
     RemoveCanonicalHost(origin);
     if (it == alternative_service_map_.end())
       return false;
 
     alternative_service_map_.Erase(it);
     return true;
   }
 
-  bool changed = true;
-  if (it != alternative_service_map_.end()) {
+  bool changed;

[Ryan Hamilton, 2016/07/21 22:27:05]

I think you can simplify this slightly:

bool changed = true;
if (it != alternative_service_map_.end()) {
  DCHECK(!it->second.empty());
  if (it->second.size() == alternative_service_info_vector.size()) {
    changed = false;
    const base::Time now = base::Time::Now();
    ....
  }
}

[Bence, 2016/07/22 16:28:54]

Done.

+  if (it == alternative_service_map_.end()) {
+    changed = true;
+  } else {
     DCHECK(!it->second.empty());
     if (it->second.size() == alternative_service_info_vector.size()) {
-      changed = !std::equal(it->second.begin(), it->second.end(),
-                            alternative_service_info_vector.begin());
+      const base::Time now = base::Time::Now();
+      changed = false;
+      auto new_it = alternative_service_info_vector.begin();
+      for (const auto& old : it->second) {
+        if (old.alternative_service != new_it->alternative_service) {
+          changed = true;
+          break;
+        }
+        base::Time old_time = old.expiration;
+        base::Time new_time = new_it->expiration;
+        if (new_time < old_time ||
+            new_time < now + base::TimeDelta::FromHours(12) ||
+            new_time - now > 2 * (old_time - now)) {

[Ryan Hamilton, 2016/07/21 22:27:04]

nit: Can you add a comment before the if(...) which says (in english) what these
three conditions are:
1) expires sooner
2) expires less than 12 hours from now
3) new expiration is more than twice as long as old expiration

That being said, I wonder a bout about #2. Imagine some site which is doing 30
minute expiration (who knows why). We'll persist every time. How about making #2
be something like:

2) new expiration is less than half as long as old expiration

[Bence, 2016/07/22 16:28:54]

Your proposed (2) is redundant with (1), so I'll just scratch it.

Also, if we do persist every five minutes anyway, there's not much value in (3)
either, so I'll scratch that too.

[Ryan Hamilton, 2016/07/22 23:31:35]

That's true. :) It makes me wonder if we would be better to have:

1) sooner than old / 2
2) later than old * 2

The current state of the CL has some buffering/delay logic in two places...
Every 5 min in the manager, and *now* here, but only if things changed enough. 
This feel odd. See my comment in the manager, perhaps we can just get rid of the
5 minute thing completely?

[Bence, 2016/07/27 16:30:55]

Done.

+          changed = true;
+          break;
+        }
+        ++new_it;
+      }
+    } else {
+      changed = true;
     }
   }
 
   const bool previously_no_alternative_services =
       (GetAlternateProtocolIterator(origin) == alternative_service_map_.end());
 
   alternative_service_map_.Put(origin, alternative_service_info_vector);
 
   if (previously_no_alternative_services &&
       !GetAlternativeServices(origin).empty()) {
@@ skipping 351 matching lines @@
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net