Track printer installations for each configuration.

chrome/browser/chromeos/printing/printers_manager.cc

 // Copyright 2016 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 "chrome/browser/chromeos/printing/printers_manager.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 72 matching lines @@
   }
 
   return printers;
 }
 
 std::vector<std::unique_ptr<Printer>> PrintersManager::GetRecommendedPrinters()
     const {
   std::vector<std::unique_ptr<Printer>> printers;
 
   for (const std::string& key : recommended_printer_ids_) {
-    const base::DictionaryValue& printer_dictionary =
-        *(recommended_printers_.at(key));
-    std::unique_ptr<Printer> printer =
-        printing::RecommendedPrinterToPrinter(printer_dictionary);
-    if (printer) {
-      printer->set_source(Printer::SRC_POLICY);
-      printers.push_back(std::move(printer));
+    auto printer = recommended_printers_.find(key);
+    if (printer != recommended_printers_.end()) {
+      printers.push_back(base::MakeUnique<Printer>(*printer->second));
     }
   }
 
   return printers;
 }
 
 std::unique_ptr<Printer> PrintersManager::GetPrinter(
     const std::string& printer_id) const {
   // check for a policy printer first
   const auto& policy_printers = recommended_printers_;
   auto found = policy_printers.find(printer_id);
-  if (found != policy_printers.end())
-    return printing::RecommendedPrinterToPrinter(*(found->second));
+  if (found != policy_printers.end()) {
+    // Copy a printer.
+    return base::MakeUnique<Printer>(*(found->second));
+  }
 
   base::Optional<sync_pb::PrinterSpecifics> printer =
       sync_bridge_->GetPrinter(printer_id);
   return printer.has_value() ? printing::SpecificsToPrinter(*printer) : nullptr;
 }
 
 void PrintersManager::RegisterPrinter(std::unique_ptr<Printer> printer) {
   if (printer->id().empty()) {
     printer->set_id(base::GenerateGUID());
   }
@@ skipping 46 matching lines @@
   return sync_bridge_.get();
 }
 
 // This method is not thread safe and could interact poorly with readers of
 // |recommended_printers_|.
 void PrintersManager::UpdateRecommendedPrinters() {
   const PrefService* prefs = profile_->GetPrefs();
 
   const base::ListValue* values =
       prefs->GetList(prefs::kRecommendedNativePrinters);
+  int64_t timestamp = base::Time::Now().ToJavaTime();
 
   recommended_printer_ids_.clear();
   for (const auto& value : *values) {
     std::string printer_json;
     if (!value.GetAsString(&printer_json)) {
       NOTREACHED();
       continue;
     }
 
     std::unique_ptr<base::DictionaryValue> printer_dictionary =
         base::DictionaryValue::From(base::JSONReader::Read(
             printer_json, base::JSON_ALLOW_TRAILING_COMMAS));
 
     if (!printer_dictionary) {
       LOG(WARNING) << "Ignoring invalid printer.  Invalid JSON object: "
                    << printer_json;
       continue;
     }
 
     // Policy printers don't have id's but the ids only need to be locally
     // unique so we'll hash the record.  This will not collide with the UUIDs
     // generated for user entries.
     std::string id = base::MD5String(printer_json);
     printer_dictionary->SetString(printing::kPrinterId, id);
 
     recommended_printer_ids_.push_back(id);

[Carlson, 2017/05/05 23:59:16]

Does this mean we're happy to push the same printer into
recommended_printer_ids_ multiple times?

[skau, 2017/05/08 18:38:02]

It's cleared on line 179.  We save the ids to keep the order stable.

[Carlson, 2017/05/08 18:49:25]

I'm still a little confused by this, sorry.

In this function, we *clear* the existing recommended_printer_ids_, but for
recommended_printers_ we selectively add the printers we haven't seen before.

I don't understand why the two structures are treated differently in this way. 
The contract in printers_manager.h says recommended_printer_ids_ contains the
keys for all recommended_printers_, and either that's not guaranteed with this
code, or   I don't understand something about how it works.

-    recommended_printers_[id] = std::move(printer_dictionary);
+    if (!base::ContainsKey(recommended_printers_, id)) {
+      auto printer =
+          printing::RecommendedPrinterToPrinter(*printer_dictionary, timestamp);
+      printer->set_source(Printer::SRC_POLICY);
+
+      recommended_printers_[id] = std::move(printer);
+    }
   }
 }
 
+void PrintersManager::PrinterInstalled(const Printer& printer) {
+  DCHECK_GT(printer.last_updated(), 0);
+  installed_printer_timestamps_[printer.id()] = printer.last_updated();
+}
+
+bool PrintersManager::IsConfigurationCurrent(const Printer& printer) {
+  auto found = installed_printer_timestamps_.find(printer.id());
+  if (found == installed_printer_timestamps_.end())
+    return false;
+
+  return found->second == printer.last_updated();
+}
+
 }  // namespace chromeos