Add PpdResolutionState class

- PpdResolution holds the state of active PpdReference resolutions.
- Will be incorporated in a later class, PpdReferenceTracker.
- Adds unit test for this class.

Bug: 932202
Test: --gtest_filter=PpdResolutionStateTest.*
Change-Id: I9135e24fd883ae06cb483dc7c12ae7d996564bfa
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1565377
Commit-Queue: jimmy gong <jimmyxgong@chromium.org>
Reviewed-by: Bailey Berro <baileyberro@chromium.org>
Reviewed-by: Zentaro Kavanagh <zentaro@chromium.org>
Cr-Commit-Position: refs/heads/master@{#650542}

chrome/browser/chromeos/BUILD.gn

@@ -1827,6 +1827,8 @@ source_set("chromeos") {
     "printing/enterprise_printers_provider.h",
     "printing/ppd_provider_factory.cc",
     "printing/ppd_provider_factory.h",
+    "printing/ppd_resolution_state.cc",
+    "printing/ppd_resolution_state.h",
     "printing/printer_configurer.cc",
     "printing/printer_configurer.h",
     "printing/printer_detector.h",
@@ -2537,6 +2539,7 @@ source_set("unit_tests") {
     "preferences_unittest.cc",
     "printing/bulk_printers_calculator_unittest.cc",
     "printing/cups_printers_manager_unittest.cc",
+    "printing/ppd_resolution_state_unittest.cc",
     "printing/printer_detector_test_util.h",
     "printing/printer_event_tracker_unittest.cc",
     "printing/printers_sync_bridge_unittest.cc",

chrome/browser/chromeos/printing/ppd_resolution_state.cc

+// Copyright 2019 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/ppd_resolution_state.h"
+
+#include <string>
+
+#include "base/logging.h"
+
+namespace chromeos {
+
+PpdResolutionState::PpdResolutionState()
+    : is_inflight_(true), is_ppd_resolution_successful_(false) {}
+
+PpdResolutionState::~PpdResolutionState() = default;
+
+void PpdResolutionState::MarkResolutionSuccessful(
+    const Printer::PpdReference& ppd_reference) {
+  DCHECK(is_inflight_);
+
+  ppd_reference_ = ppd_reference;
+  is_inflight_ = false;
+  is_ppd_resolution_successful_ = true;
+}
+
+void PpdResolutionState::MarkResolutionFailed() {
+  DCHECK(is_inflight_);
+
+  is_inflight_ = false;
+  is_ppd_resolution_successful_ = false;
+}
+
+void PpdResolutionState::SetUsbManufacturer(
+    const std::string& usb_manufacturer) {
+  DCHECK(!is_inflight_);
+  DCHECK(!is_ppd_resolution_successful_);
+
+  usb_manufacturer_ = usb_manufacturer;
+}
+
+const Printer::PpdReference& PpdResolutionState::GetPpdReference() const {
+  DCHECK(!is_inflight_);
+  DCHECK(is_ppd_resolution_successful_);
+  return ppd_reference_;
+}
+
+const std::string& PpdResolutionState::GetUsbManufacturer() const {
+  DCHECK(!is_inflight_);
+  return usb_manufacturer_;
+}
+
+bool PpdResolutionState::IsInflight() const {
+  return is_inflight_;
+}
+
+bool PpdResolutionState::WasResolutionSuccessful() const {
+  return is_ppd_resolution_successful_;
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/printing/ppd_resolution_state.h

+// Copyright 2019 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_PRINTING_PPD_RESOLUTION_STATE_H_
+#define CHROME_BROWSER_CHROMEOS_PRINTING_PPD_RESOLUTION_STATE_H_
+
+#include <string>
+
+#include "chromeos/printing/printer_configuration.h"
+
+namespace chromeos {
+
+class PpdResolutionState {
+ public:
+  PpdResolutionState();
+  ~PpdResolutionState();
+
+  // Marks PPD resolution was successful and stores |ppd_reference|.
+  void MarkResolutionSuccessful(const Printer::PpdReference& ppd_reference);
+
+  // Marks PPD resolution was unsuccessful.
+  void MarkResolutionFailed();
+
+  // Store |usb_manufacturer|.
+  void SetUsbManufacturer(const std::string& usb_manufacturer);
+
+  // Getter function for |ppd_reference_|.
+  const Printer::PpdReference& GetPpdReference() const;
+
+  // Getter function for |usb_manufacturer_|.
+  const std::string& GetUsbManufacturer() const;
+
+  // Returns true if the PPD resolution is inflight.
+  bool IsInflight() const;
+
+  // Returns true if a PpdReference was retrieved.
+  bool WasResolutionSuccessful() const;
+
+ private:
+  bool is_inflight_;
+  bool is_ppd_resolution_successful_;
+  Printer::PpdReference ppd_reference_;
+  std::string usb_manufacturer_;
+
+  DISALLOW_COPY_AND_ASSIGN(PpdResolutionState);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_PRINTING_PPD_RESOLUTION_STATE_H_

chrome/browser/chromeos/printing/ppd_resolution_state_unittest.cc

+// Copyright 2019 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/ppd_resolution_state.h"
+
+#include "base/macros.h"
+#include "chromeos/printing/printer_configuration.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace {
+
+class PpdResolutionStateTest : public testing::Test {
+ public:
+  PpdResolutionStateTest() = default;
+  ~PpdResolutionStateTest() override = default;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PpdResolutionStateTest);
+};
+
+TEST_F(PpdResolutionStateTest, TestDefaultState) {
+  PpdResolutionState ppd_resolution_state_;
+
+  EXPECT_TRUE(ppd_resolution_state_.IsInflight());
+  EXPECT_FALSE(ppd_resolution_state_.WasResolutionSuccessful());
+}
+
+TEST_F(PpdResolutionStateTest, TestMarkPpdResolutionSucessful) {
+  PpdResolutionState ppd_resolution_state_;
+
+  const std::string expected_make_and_model = "printer_make_model";
+  Printer::PpdReference ppd_ref;
+  ppd_ref.effective_make_and_model = expected_make_and_model;
+
+  ppd_resolution_state_.MarkResolutionSuccessful(ppd_ref);
+
+  EXPECT_FALSE(ppd_resolution_state_.IsInflight());
+  EXPECT_TRUE(ppd_resolution_state_.WasResolutionSuccessful());
+
+  const Printer::PpdReference ref = ppd_resolution_state_.GetPpdReference();
+
+  EXPECT_EQ(expected_make_and_model, ref.effective_make_and_model);
+  EXPECT_TRUE(ref.user_supplied_ppd_url.empty());
+  EXPECT_FALSE(ref.autoconf);
+}
+
+TEST_F(PpdResolutionStateTest, TestMarkResolutionFailedAndSetUsbManufacturer) {
+  PpdResolutionState ppd_resolution_state_;
+
+  ppd_resolution_state_.MarkResolutionFailed();
+
+  EXPECT_FALSE(ppd_resolution_state_.IsInflight());
+  EXPECT_FALSE(ppd_resolution_state_.WasResolutionSuccessful());
+
+  const std::string expected_usb_manufacturer = "Hewlett-Packard";
+  ppd_resolution_state_.SetUsbManufacturer(expected_usb_manufacturer);
+
+  EXPECT_EQ(expected_usb_manufacturer,
+            ppd_resolution_state_.GetUsbManufacturer());
+}
+
+}  // namespace
+}  // namespace chromeos