cros: Fold HIDDetectionModel into HIDDetectionScreen.

chrome/browser/chromeos/login/screens/hid_detection_screen.h

 // Copyright 2014 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_LOGIN_SCREENS_HID_DETECTION_SCREEN_H_
 #define CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_HID_DETECTION_SCREEN_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/chromeos/device/input_service_proxy.h"
 #include "chrome/browser/chromeos/login/screens/base_screen.h"
-#include "chrome/browser/chromeos/login/screens/hid_detection_model.h"
 #include "components/login/screens/screen_context.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/hid/input_service_linux.h"
 
 namespace chromeos {
 
 class HIDDetectionView;
 
 // Representation independent class that controls screen showing warning about
 // HID absence to users.
-class HIDDetectionScreen : public HIDDetectionModel,
+class HIDDetectionScreen : public BaseScreen,
                            public device::BluetoothAdapter::Observer,
                            public device::BluetoothDevice::PairingDelegate,
                            public InputServiceProxy::Observer {
  public:
-  typedef device::InputServiceLinux::InputDeviceInfo InputDeviceInfo;
+  static const char kContextKeyKeyboardState[];
+  static const char kContextKeyMouseState[];
+  static const char kContextKeyNumKeysEnteredExpected[];
+  static const char kContextKeyNumKeysEnteredPinCode[];
+  static const char kContextKeyPinCode[];
+  static const char kContextKeyMouseDeviceName[];
+  static const char kContextKeyKeyboardDeviceName[];
+  static const char kContextKeyKeyboardLabel[];
+  static const char kContextKeyContinueButtonEnabled[];
+
+  using InputDeviceInfo = device::InputServiceLinux::InputDeviceInfo;
 
   class Delegate {
    public:
     virtual ~Delegate() {}
     virtual void OnHIDScreenNecessityCheck(bool screen_needed) = 0;
   };
 
   HIDDetectionScreen(BaseScreenDelegate* base_screen_delegate,
                      HIDDetectionView* view);
   ~HIDDetectionScreen() override;
 
-  // HIDDetectionModel implementation:
+  // Called when continue button was clicked.
+  void OnContinueButtonClicked();
+
+  // This method is called when the view is being destroyed.
+  void OnViewDestroyed(HIDDetectionView* view);
+
+  // Checks if this screen should be display. |on_check_done| should be invoked

[achuithb, 2017/01/20 19:18:38]

displayed

[jdufault, 2017/01/20 19:25:37]

Done.

+  // with the result; true if the screen should be displayed, false otherwise.
+  void CheckIsScreenRequired(const base::Callback<void(bool)>& on_check_done);
+
+ private:
+  friend class HIDDetectionScreenTest;
+
+  // BaseScreen implementation:
   void Show() override;
   void Hide() override;
-  void OnContinueButtonClicked() override;
-  void OnViewDestroyed(HIDDetectionView* view) override;
-  void CheckIsScreenRequired(
-      const base::Callback<void(bool)>& on_check_done) override;
 
   // device::BluetoothDevice::PairingDelegate implementation:
   void RequestPinCode(device::BluetoothDevice* device) override;
   void RequestPasskey(device::BluetoothDevice* device) override;
   void DisplayPinCode(device::BluetoothDevice* device,
                       const std::string& pincode) override;
   void DisplayPasskey(device::BluetoothDevice* device,
                       uint32_t passkey) override;
   void KeysEntered(device::BluetoothDevice* device, uint32_t entered) override;
   void ConfirmPasskey(device::BluetoothDevice* device,
                       uint32_t passkey) override;
   void AuthorizePairing(device::BluetoothDevice* device) override;
 
   // device::BluetoothAdapter::Observer implementation.
   void AdapterPresentChanged(device::BluetoothAdapter* adapter,
                              bool present) override;
   void DeviceAdded(device::BluetoothAdapter* adapter,
                    device::BluetoothDevice* device) override;
   void DeviceChanged(device::BluetoothAdapter* adapter,
                      device::BluetoothDevice* device) override;
   void DeviceRemoved(device::BluetoothAdapter* adapter,
                      device::BluetoothDevice* device) override;
 
   // InputServiceProxy::Observer implementation.
   void OnInputDeviceAdded(const InputDeviceInfo& info) override;
   void OnInputDeviceRemoved(const std::string& id) override;
 
- private:
-  friend class HIDDetectionScreenTest;
-
   // Types of dialog leaving scenarios for UMA metric.
   enum ContinueScenarioType {
     // Only pointing device detected, user pressed 'Continue'.
     POINTING_DEVICE_ONLY_DETECTED,
 
     // Only keyboard detected, user pressed 'Continue'.
     KEYBOARD_DEVICE_ONLY_DETECTED,
 
     // All devices detected.
     All_DEVICES_DETECTED,
@@ skipping 122 matching lines @@
   bool showing_ = false;
 
   base::WeakPtrFactory<HIDDetectionScreen> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HIDDetectionScreen);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_HID_DETECTION_SCREEN_H_