[Doodle] Pull time_to_live out of DoodleConfig

components/doodle/doodle_service.cc

 // Copyright 2017 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/doodle/doodle_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
+#include "base/time/time.h"
 
 namespace doodle {
 
 DoodleService::DoodleService(std::unique_ptr<DoodleFetcher> fetcher)
     : fetcher_(std::move(fetcher)) {
   DCHECK(fetcher_);
 }
 
 DoodleService::~DoodleService() = default;
 
 void DoodleService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DoodleService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void DoodleService::Refresh() {
   fetcher_->FetchDoodle(
       base::BindOnce(&DoodleService::DoodleFetched, base::Unretained(this)));
 }
 
 void DoodleService::DoodleFetched(
     DoodleState state,
+    base::TimeDelta time_to_live,
     const base::Optional<DoodleConfig>& doodle_config) {
-  if (!cached_config_.has_value() && !doodle_config.has_value()) {
-    // There was no config before and we didn't get a new one, so there's
-    // nothing to do.
+  // If nothing changed, then there's nothing to do. Note that this checks both
+  // for existence changes as well as changes of the configs themselves.
+  if (cached_config_ == doodle_config) {
+    // TODO(treib): Once we support expiry, update the time to live here.
     return;
   }
 
-  bool notify = false;
-  if (cached_config_.has_value() != doodle_config.has_value()) {
-    // We got a new config, or an existing one went away.
-    notify = true;
-  } else {
-    // There was a config both before and after the update. Notify observers
-    // only if something relevant changed.
-    notify = !cached_config_.value().IsEquivalent(doodle_config.value());
-  }
-
-  // In any case, update the cache.
+  // Update the cache and notify observers.
   cached_config_ = doodle_config;
-
-  if (notify) {
-    for (auto& observer : observers_) {
-      observer.OnDoodleConfigUpdated(cached_config_);
-    }
+  for (auto& observer : observers_) {

[fhorschig, 2017/03/02 13:18:08]

Is non-const auto& something we are allowed to use?

I can not find any decision related to that. 
Codesearch says 50:50 auto* vs auto& ...

So, do as you like, I would prefer a pointer type.
(But I am aware that an observer notification is 
almost impossible to be const.)

[Marc Treib, 2017/03/02 14:30:08]

Yes (for locally-scoped stuff like this).
This is actually the default usage of ObserverList:
https://cs.chromium.org/chromium/src/base/observer_list.h?rcl=d83555d59cc6dba...
It's not a pointer, the auto& resolves to Observer&.

+    observer.OnDoodleConfigUpdated(cached_config_);
   }
 }
 
 }  // namespace doodle