[go: nahoru, domu]

blob: 63cc24384e569e35c4c68b6158f7990f0a8ca843 [file] [log] [blame]
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_DISPLAY_MANAGER_TEST_TEST_NATIVE_DISPLAY_DELEGATE_H_
#define UI_DISPLAY_MANAGER_TEST_TEST_NATIVE_DISPLAY_DELEGATE_H_
#include <stdint.h>
#include <vector>
#include "base/containers/flat_map.h"
#include "base/memory/raw_ptr.h"
#include "base/observer_list.h"
#include "ui/display/manager/test/action_logger.h"
#include "ui/display/manager/test/action_logger_util.h"
#include "ui/display/types/native_display_delegate.h"
namespace display {
class ActionLogger;
class DisplaySnapshot;
class NativeDisplayObserver;
namespace test {
constexpr char kTestModesetStr[] = "test-modeset";
constexpr char kCommitModesetStr[] = "commit-modeset";
constexpr char kSeamlessModesetStr[] = "seamless-modeset";
constexpr char kModesetOutcomeFailure[] = "outcome: failure";
constexpr char kModesetOutcomeSuccess[] = "outcome: success";
class TestNativeDisplayDelegate : public NativeDisplayDelegate {
public:
// Ownership of |log| remains with the caller.
explicit TestNativeDisplayDelegate(ActionLogger* log);
TestNativeDisplayDelegate(const TestNativeDisplayDelegate&) = delete;
TestNativeDisplayDelegate& operator=(const TestNativeDisplayDelegate&) =
delete;
~TestNativeDisplayDelegate() override;
const std::vector<DisplaySnapshot*>& outputs() const { return outputs_; }
void set_outputs(const std::vector<DisplaySnapshot*>& outputs) {
outputs_ = outputs;
}
void set_max_configurable_pixels(int pixels) {
max_configurable_pixels_ = pixels;
}
void set_system_bandwidth_limit(int bandwidth_limit) {
system_bandwidth_limit_ = bandwidth_limit;
}
void set_get_hdcp_state_expectation(bool success) {
get_hdcp_expectation_ = success;
}
void set_set_hdcp_state_expectation(bool success) {
set_hdcp_expectation_ = success;
}
HDCPState hdcp_state() const { return hdcp_state_; }
void set_hdcp_state(HDCPState state) { hdcp_state_ = state; }
ContentProtectionMethod content_protection_method() const {
return content_protection_method_;
}
void set_content_protection_method(
ContentProtectionMethod protection_method) {
content_protection_method_ = protection_method;
}
void set_run_async(bool run_async) { run_async_ = run_async; }
// NativeDisplayDelegate overrides:
void Initialize() override;
void TakeDisplayControl(DisplayControlCallback callback) override;
void RelinquishDisplayControl(DisplayControlCallback callback) override;
void GetDisplays(GetDisplaysCallback callback) override;
void Configure(
const std::vector<display::DisplayConfigurationParams>& config_requests,
ConfigureCallback callback,
uint32_t modeset_flag) override;
void SetHdcpKeyProp(int64_t display_id,
const std::string& key,
SetHdcpKeyPropCallback callback) override;
void GetHDCPState(const DisplaySnapshot& output,
GetHDCPStateCallback callback) override;
void SetHDCPState(const DisplaySnapshot& output,
HDCPState state,
ContentProtectionMethod protection_method,
SetHDCPStateCallback callback) override;
bool SetColorMatrix(int64_t display_id,
const std::vector<float>& color_matrix) override;
bool SetGammaCorrection(int64_t display_id,
const display::GammaCurve& degamma,
const display::GammaCurve& gamma) override;
void SetPrivacyScreen(int64_t display_id,
bool enabled,
SetPrivacyScreenCallback callback) override;
void AddObserver(NativeDisplayObserver* observer) override;
void RemoveObserver(NativeDisplayObserver* observer) override;
FakeDisplayController* GetFakeDisplayController() override;
private:
bool Configure(
const display::DisplayConfigurationParams& display_config_params);
void DoSetHDCPState(int64_t display_id,
HDCPState state,
ContentProtectionMethod protection_method,
SetHDCPStateCallback callback);
bool IsConfigurationWithinSystemBandwidth(
const std::vector<display::DisplayConfigurationParams>& config_requests);
void SaveCurrentConfigSystemBandwidth(
const std::vector<display::DisplayConfigurationParams>& config_requests);
// Outputs to be returned by GetDisplays().
std::vector<DisplaySnapshot*> outputs_;
// |max_configurable_pixels_| represents the maximum number of pixels that
// Configure will support. Tests can use this to force Configure
// to fail if attempting to set a resolution that is higher than what
// a device might support under a given circumstance.
// A value of 0 means that no limit is enforced and Configure will
// return success regardless of the resolution.
int max_configurable_pixels_;
int system_bandwidth_limit_ = 0;
base::flat_map<int64_t, int> display_id_to_used_system_bw_;
bool get_hdcp_expectation_;
bool set_hdcp_expectation_;
// Result value of GetHDCPState().
HDCPState hdcp_state_;
ContentProtectionMethod content_protection_method_;
// If true, the callbacks are posted on the message loop.
bool run_async_;
raw_ptr<ActionLogger, DanglingUntriaged | ExperimentalAsh>
log_; // Not owned.
base::ObserverList<NativeDisplayObserver>::Unchecked observers_;
};
} // namespace test
} // namespace display
#endif // UI_DISPLAY_MANAGER_TEST_TEST_NATIVE_DISPLAY_DELEGATE_H_