Introduce the field make_and_model for synced printers.

chrome/browser/chromeos/printing/specifics_translation.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 <memory>
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/printing/specifics_translation.h"
 #include "chromeos/printing/printer_configuration.h"
 #include "components/sync/protocol/printer_specifics.pb.h"
 
 namespace chromeos {
 namespace printing {
 
 namespace {
 
@@ skipping 21 matching lines @@
     specifics->set_autoconf(ref.autoconf);
   } else if (!ref.user_supplied_ppd_url.empty()) {
     specifics->Clear();
     specifics->set_user_supplied_ppd_url(ref.user_supplied_ppd_url);
   } else if (!ref.effective_make_and_model.empty()) {
     specifics->Clear();
     specifics->set_effective_make_and_model(ref.effective_make_and_model);
   }
 }
 
+std::string MakeAndModel(base::StringPiece make, base::StringPiece model) {

[Carlson, 2017/06/28 17:38:36]

Function comment.  Also, I'm not 100% sure this will do the right thing in all
places.  Do we have any printers that are, for instance, make: "Hewlett Packard"
but model "HP LaserJet 5 bajillion"?
 
If we do, it may be a small enough subset that we don't care.

[skau, 2017/06/28 21:25:35]

I think it's a small enough subset.  Mostly, I'm trying to account for existing
data that has the effective_make_and_model string saved in the model field.

+  return model.starts_with(make) ? model.as_string()
+                                 : base::JoinString({make, model}, " ");
+}
+
 }  // namespace
 
 std::unique_ptr<Printer> SpecificsToPrinter(
     const sync_pb::PrinterSpecifics& specifics) {
   DCHECK(!specifics.id().empty());
 
   auto printer = base::MakeUnique<Printer>(
       specifics.id(), base::Time::FromJavaTime(specifics.updated_timestamp()));
   printer->set_display_name(specifics.display_name());
   printer->set_description(specifics.description());
   printer->set_manufacturer(specifics.manufacturer());
   printer->set_model(specifics.model());
+  if (!specifics.make_and_model().empty()) {
+    printer->set_make_and_model(specifics.make_and_model());
+  } else {
+    printer->set_make_and_model(
+        MakeAndModel(specifics.manufacturer(), specifics.model()));
+  }
   printer->set_uri(specifics.uri());
   printer->set_uuid(specifics.uuid());
 
   *printer->mutable_ppd_reference() = SpecificsToPpd(specifics.ppd_reference());
 
   return printer;
 }
 
 std::unique_ptr<sync_pb::PrinterSpecifics> PrinterToSpecifics(
     const Printer& printer) {
@@ skipping 15 matching lines @@
 
   if (!printer.description().empty())
     specifics->set_description(printer.description());
 
   if (!printer.manufacturer().empty())
     specifics->set_manufacturer(printer.manufacturer());
 
   if (!printer.model().empty())
     specifics->set_model(printer.model());
 
+  if (!printer.make_and_model().empty())
+    specifics->set_make_and_model(printer.make_and_model());
+
   if (!printer.uri().empty())
     specifics->set_uri(printer.uri());
 
   if (!printer.uuid().empty())
     specifics->set_uuid(printer.uuid());
 
   MergeReferenceToSpecifics(specifics->mutable_ppd_reference(),
                             printer.ppd_reference());
 }
 
 }  // namespace printing
 }  // namespace chromeos