Add a PrinterDiscoverer fake object.

chromeos/printing/fake_printer_discoverer.cc

Index: chromeos/printing/fake_printer_discoverer.cc
diff --git a/chromeos/printing/fake_printer_discoverer.cc b/chromeos/printing/fake_printer_discoverer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7069b87d8b9f63ff5d8d41a77099fdcd2c3a7327
--- /dev/null
+++ b/chromeos/printing/fake_printer_discoverer.cc
@@ -0,0 +1,93 @@
+// 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 "chromeos/printing/fake_printer_discoverer.h"
+
+#include <algorithm>
+#include <iterator>
+#include <memory>
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/time/time.h"
+#include "chromeos/printing/printer_discoverer.h"
+
+namespace chromeos {
+
+// static
+std::unique_ptr<PrinterDiscoverer> PrinterDiscoverer::Create() {
+  return base::MakeUnique<FakePrinterDiscoverer>();

[xdai1, 2016/10/03 23:34:38]

It might be better to make it a lazy instance so that it will only be created
when user sets up a printer? Something like:
 static base::LazyInstance<FakePrinterDiscovery> g_printer_discovery =
     LAZY_INSTANCE_INITIALIZER;
 
 // static
 PrinterDiscovery* PrinterDiscovery::GetInstance() {
   return g_printer_discovery.Pointer();
 }

[skau, 2016/10/03 23:52:30]

My intention is that this object is only around while the dialog is open.  Won't
the lazy instance imply that it sticks around when it's not being used?

[xdai1, 2016/10/04 00:13:32]

Acknowledged. Didn't thought about this way.

+}
+
+FakePrinterDiscoverer::~FakePrinterDiscoverer() {}
+
+bool FakePrinterDiscoverer::StartDiscovery() {
+  discovery_running_ = true;
+  base::SequencedTaskRunnerHandle::Get()->PostNonNestableDelayedTask(
+      FROM_HERE, base::Bind(&FakePrinterDiscoverer::EmitPrinters,
+                            weak_ptr_factory_.GetWeakPtr(), 0, 2),
+      base::TimeDelta::FromMilliseconds(2000));
+  return true;
+}
+
+bool FakePrinterDiscoverer::StopDiscovery() {
+  discovery_running_ = false;
+  return true;
+}
+
+void FakePrinterDiscoverer::AddObserver(PrinterDiscoverer::Observer* observer) {
+  observers_.push_back(observer);
+}
+
+void FakePrinterDiscoverer::RemoveObserver(
+    PrinterDiscoverer::Observer* observer) {
+  auto found = std::find(observers_.begin(), observers_.end(), observer);
+  if (found != observers_.end())
+    observers_.erase(found);
+}
+
+FakePrinterDiscoverer::FakePrinterDiscoverer()
+    : discovery_running_(false), weak_ptr_factory_(this) {
+  for (int i = 0; i < 12; i++) {
+    // printer doesn't have a ppd
+    printers_.emplace_back(base::StringPrintf("GUID%2d", i));
+    printers_[i].set_display_name(base::StringPrintf("PrinterName%2d", i));
+    printers_[i].set_description(
+        base::StringPrintf("Printer%2dDescription", i));
+    printers_[i].set_manufacturer("Chromium");
+    printers_[i].set_model(i % 3 == 0 ? "Inkjet" : "Laser Maker");
+    printers_[i].set_uri(
+        base::StringPrintf("lpr://192.168.1.%d:9100/bldg/printer", i));
+    printers_[i].set_uuid(
+        base::StringPrintf("UUID-%4d-%4d-%4d-UUID", i * 3, i * 2, i));
+  }
+}
+
+void FakePrinterDiscoverer::EmitPrinters(size_t start, size_t end) {
+  if (!discovery_running_ || start >= printers_.size())

[Carlson, 2016/10/03 23:13:23]

For orthogonality, suggest adding

 || end < 0

to this. 

[skau, 2016/10/03 23:34:48]

Done.

+    return;

[xdai1, 2016/10/03 23:34:38]

notify when the discovery is done.

[skau, 2016/10/03 23:52:30]

Whoops.  Forgot about that.

+
+  size_t clipped_start = std::max(static_cast<size_t>(0), start);
+  size_t clipped_end = std::min(printers_.size(), end);
+  if (!observers_.empty()) {
+    std::vector<Printer> subset(printers_.cbegin() + clipped_start,
+                                printers_.cbegin() + clipped_end);
+
+    for (auto observer : observers_)
+      observer->OnPrintersFound(subset);
+  }
+
+  // schedule another emit if elements remain.
+  if (end < printers_.size()) {
+    base::SequencedTaskRunnerHandle::Get()->PostNonNestableDelayedTask(
+        FROM_HERE,
+        base::Bind(&FakePrinterDiscoverer::EmitPrinters,
+                   weak_ptr_factory_.GetWeakPtr(), clipped_end, end + end),
+        base::TimeDelta::FromMilliseconds(2000));
+  }
+}
+
+}  // namespace chromeos