blob: a431a2a2f652418470ae1c24b3b7fbfb081d232a [file] [log] [blame]
// 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 "ui/display/fake_display_snapshot.h"
#include <inttypes.h>
#include <sstream>
#include <utility>
#include <vector>
#include "base/memory/ptr_util.h"
#include "base/strings/stringprintf.h"
namespace display {
namespace {
static const float kInchInMm = 25.4f;
// Get pixel pitch in millimeters from DPI.
float PixelPitchMmFromDPI(float dpi) {
return (1.0f / dpi) * kInchInMm;
}
std::string ModeListString(
const std::vector<std::unique_ptr<const ui::DisplayMode>>& modes) {
std::stringstream stream;
bool first = true;
for (auto& mode : modes) {
if (!first)
stream << ", ";
stream << mode->ToString();
first = false;
}
return stream.str();
}
std::string DisplayConnectionTypeString(ui::DisplayConnectionType type) {
switch (type) {
case ui::DISPLAY_CONNECTION_TYPE_NONE:
return "none";
case ui::DISPLAY_CONNECTION_TYPE_UNKNOWN:
return "unknown";
case ui::DISPLAY_CONNECTION_TYPE_INTERNAL:
return "internal";
case ui::DISPLAY_CONNECTION_TYPE_VGA:
return "vga";
case ui::DISPLAY_CONNECTION_TYPE_HDMI:
return "hdmi";
case ui::DISPLAY_CONNECTION_TYPE_DVI:
return "dvi";
case ui::DISPLAY_CONNECTION_TYPE_DISPLAYPORT:
return "dp";
case ui::DISPLAY_CONNECTION_TYPE_NETWORK:
return "network";
case ui::DISPLAY_CONNECTION_TYPE_VIRTUAL:
return "virtual";
}
NOTREACHED();
return "";
}
} // namespace
using Builder = FakeDisplaySnapshot::Builder;
Builder::Builder() {}
Builder::~Builder() {}
std::unique_ptr<FakeDisplaySnapshot> Builder::Build() {
if (modes_.empty() || id_ == Display::kInvalidDisplayID) {
NOTREACHED() << "Display modes or display ID missing";
return nullptr;
}
// If there is no native mode set, use the first display mode.
if (!native_mode_)
native_mode_ = modes_.back().get();
// Calculate physical size to match set DPI.
gfx::Size physical_size =
gfx::ScaleToRoundedSize(native_mode_->size(), PixelPitchMmFromDPI(dpi_));
return base::WrapUnique(new FakeDisplaySnapshot(
id_, origin_, physical_size, type_, is_aspect_preserving_scaling_,
has_overscan_, has_color_correction_matrix_, name_, product_id_,
std::move(modes_), current_mode_, native_mode_));
}
Builder& Builder::SetId(int64_t id) {
id_ = id;
return *this;
}
Builder& Builder::SetNativeMode(const gfx::Size& size) {
native_mode_ = AddOrFindDisplayMode(size);
return *this;
}
Builder& Builder::SetCurrentMode(const gfx::Size& size) {
current_mode_ = AddOrFindDisplayMode(size);
return *this;
}
Builder& Builder::AddMode(const gfx::Size& size) {
AddOrFindDisplayMode(size);
return *this;
}
Builder& Builder::SetOrigin(const gfx::Point& origin) {
origin_ = origin;
return *this;
}
Builder& Builder::SetType(ui::DisplayConnectionType type) {
type_ = type;
return *this;
}
Builder& Builder::SetIsAspectPerservingScaling(bool val) {
is_aspect_preserving_scaling_ = val;
return *this;
}
Builder& Builder::SetHasOverscan(bool has_overscan) {
has_overscan_ = has_overscan;
return *this;
}
Builder& Builder::SetHasColorCorrectionMatrix(bool val) {
has_color_correction_matrix_ = val;
return *this;
}
Builder& Builder::SetName(const std::string& name) {
name_ = name;
return *this;
}
Builder& Builder::SetProductId(int64_t product_id) {
product_id_ = product_id;
return *this;
}
Builder& Builder::SetDPI(int dpi) {
dpi_ = static_cast<float>(dpi);
return *this;
}
Builder& Builder::SetLowDPI() {
return SetDPI(96);
}
Builder& Builder::SetHighDPI() {
return SetDPI(326); // Retina-ish.
}
const ui::DisplayMode* Builder::AddOrFindDisplayMode(const gfx::Size& size) {
for (auto& mode : modes_) {
if (mode->size() == size)
return mode.get();
}
// Not found, insert a mode with the size and return.
modes_.push_back(base::MakeUnique<ui::DisplayMode>(size, false, 60.0f));
return modes_.back().get();
}
FakeDisplaySnapshot::FakeDisplaySnapshot(
int64_t display_id,
const gfx::Point& origin,
const gfx::Size& physical_size,
ui::DisplayConnectionType type,
bool is_aspect_preserving_scaling,
bool has_overscan,
bool has_color_correction_matrix,
std::string display_name,
int64_t product_id,
std::vector<std::unique_ptr<const ui::DisplayMode>> modes,
const ui::DisplayMode* current_mode,
const ui::DisplayMode* native_mode)
: DisplaySnapshot(display_id,
origin,
physical_size,
type,
is_aspect_preserving_scaling,
has_overscan,
has_color_correction_matrix,
display_name,
base::FilePath(),
std::move(modes),
std::vector<uint8_t>(),
current_mode,
native_mode) {
product_id_ = product_id;
}
FakeDisplaySnapshot::~FakeDisplaySnapshot() {}
std::string FakeDisplaySnapshot::ToString() const {
return base::StringPrintf(
"id=%" PRId64
" current_mode=%s native_mode=%s origin=%s"
" physical_size=%s, type=%s name=\"%s\" modes=(%s)",
display_id_,
current_mode_ ? current_mode_->ToString().c_str() : "nullptr",
native_mode_ ? native_mode_->ToString().c_str() : "nullptr",
origin_.ToString().c_str(), physical_size_.ToString().c_str(),
DisplayConnectionTypeString(type_).c_str(), display_name_.c_str(),
ModeListString(modes_).c_str());
}
} // namespace display