static FillLayer* accessFillLayer(CSSPropertyID property,
ComputedStyle& style) {
switch (property) {
case CSSPropertyBackgroundSize:
return &style.accessBackgroundLayers();
case CSSPropertyWebkitMaskSize:
return &style.accessMaskLayers();
default:
NOTREACHED();
return nullptr;
}
}
String MIDIPort::state() const {
switch (m_state) {
case PortState::DISCONNECTED:
return "disconnected";
case PortState::CONNECTED:
return "connected";
case PortState::OPENED:
NOTREACHED();
return "connected";
}
return emptyString();
}
void NativeTextfieldWin::OnSetFocus(HWND hwnd)
{
SetMsgHandled(FALSE); // We still want the default processing of the message.
FocusManager* focus_manager = textfield_->GetFocusManager();
if(!focus_manager)
{
NOTREACHED();
return;
}
focus_manager->SetFocusedView(textfield_);
}
void FocusManager::UnregisterAccelerator(const Accelerator& accelerator,
AcceleratorTarget* target)
{
AcceleratorMap::iterator map_iter = accelerators_.find(accelerator);
if(map_iter == accelerators_.end())
{
NOTREACHED() << "Unregistering non-existing accelerator";
return;
}
AcceleratorTargetList* targets = &map_iter->second;
AcceleratorTargetList::iterator target_iter =
std::find(targets->begin(), targets->end(), target);
if(target_iter == targets->end())
{
NOTREACHED() << "Unregistering accelerator for wrong target";
return;
}
targets->erase(target_iter);
}
static const FillLayer* getFillLayer(CSSPropertyID property,
const ComputedStyle& style) {
switch (property) {
case CSSPropertyBackgroundSize:
return &style.backgroundLayers();
case CSSPropertyWebkitMaskSize:
return &style.maskLayers();
default:
NOTREACHED();
return nullptr;
}
}
InterpolationValue FilterInterpolationFunctions::maybeConvertFilter(
const FilterOperation& filter,
double zoom) {
InterpolationValue result = nullptr;
switch (filter.type()) {
case FilterOperation::GRAYSCALE:
case FilterOperation::HUE_ROTATE:
case FilterOperation::SATURATE:
case FilterOperation::SEPIA:
result.interpolableValue = InterpolableNumber::create(
toBasicColorMatrixFilterOperation(filter).amount());
break;
case FilterOperation::BRIGHTNESS:
case FilterOperation::CONTRAST:
case FilterOperation::INVERT:
case FilterOperation::OPACITY:
result.interpolableValue = InterpolableNumber::create(
toBasicComponentTransferFilterOperation(filter).amount());
break;
case FilterOperation::BLUR:
result = LengthInterpolationFunctions::maybeConvertLength(
toBlurFilterOperation(filter).stdDeviation(), zoom);
break;
case FilterOperation::DROP_SHADOW: {
const DropShadowFilterOperation& blurFilter =
toDropShadowFilterOperation(filter);
ShadowData shadowData(blurFilter.location(), blurFilter.stdDeviation(), 0,
Normal, blurFilter.getColor());
result =
ShadowInterpolationFunctions::convertShadowData(shadowData, zoom);
break;
}
case FilterOperation::REFERENCE:
return nullptr;
default:
NOTREACHED();
return nullptr;
}
if (!result)
return nullptr;
result.nonInterpolableValue = FilterNonInterpolableValue::create(
filter.type(), result.nonInterpolableValue.release());
return result;
}
String Notification::dir() const {
switch (m_data.direction) {
case WebNotificationData::DirectionLeftToRight:
return "ltr";
case WebNotificationData::DirectionRightToLeft:
return "rtl";
case WebNotificationData::DirectionAuto:
return "auto";
}
NOTREACHED();
return String();
}
void SQLiteDatabase::setAuthorizer(DatabaseAuthorizer* auth)
{
if (!m_db) {
NOTREACHED() << "Attempt to set an authorizer on a non-open SQL database";
return;
}
MutexLocker locker(m_authorizerLock);
m_authorizer = auth;
enableAuthorizer(true);
}
void RTCDataChannel::didReceiveRawData(const char* data, size_t dataLength)
{
if (m_binaryType == BinaryTypeBlob) {
// FIXME: Implement.
return;
}
if (m_binaryType == BinaryTypeArrayBuffer) {
DOMArrayBuffer* buffer = DOMArrayBuffer::create(data, dataLength);
scheduleDispatchEvent(MessageEvent::create(buffer));
return;
}
NOTREACHED();
}
v8::Local<v8::Value> toV8(const NodeOrNodeList& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate) {
switch (impl.m_type) {
case NodeOrNodeList::SpecificTypeNone:
return v8::Null(isolate);
case NodeOrNodeList::SpecificTypeNode:
return toV8(impl.getAsNode(), creationContext, isolate);
case NodeOrNodeList::SpecificTypeNodeList:
return toV8(impl.getAsNodeList(), creationContext, isolate);
default:
NOTREACHED();
}
return v8::Local<v8::Value>();
}
ConnectionBaseWidget* ConnectionWidgetsFactory::createWidget(proxy::IConnectionSettingsBase* connection,
QWidget* parent) {
if (!connection) {
NOTREACHED();
return nullptr;
}
core::connectionTypes type = connection->GetType();
ConnectionBaseWidget* widget = createWidgetImpl(type, parent);
widget->syncControls(connection);
widget->retranslateUi();
return widget;
}
common::Error LmdbRaw::info(const char* args, LmdbServerInfo::Stats* statsout) {
if (!statsout) {
NOTREACHED();
return common::make_error_value("Invalid input argument for command: INFO",
common::ErrorValue::E_ERROR);
}
LmdbServerInfo::Stats linfo;
linfo.file_name = config_.dbname;
*statsout = linfo;
return common::Error();
}
String SourceInfo::kind() const {
switch (m_webSourceInfo.kind()) {
case WebSourceInfo::SourceKindAudio:
return "audio";
case WebSourceInfo::SourceKindVideo:
return "video";
case WebSourceInfo::SourceKindNone:
return "none";
}
NOTREACHED();
return String();
}
void FocusManager::RemoveFocusChangeListener(FocusChangeListener* listener)
{
FocusChangeListenerList::iterator place = std::find(
focus_change_listeners_.begin(),
focus_change_listeners_.end(),
listener);
if(place == focus_change_listeners_.end())
{
NOTREACHED() << "Removing a listener that isn't registered.";
return;
}
focus_change_listeners_.erase(place);
}
String SourceInfo::facing() const {
switch (m_webSourceInfo.facing()) {
case WebSourceInfo::VideoFacingModeNone:
return String();
case WebSourceInfo::VideoFacingModeUser:
return "user";
case WebSourceInfo::VideoFacingModeEnvironment:
return "environment";
}
NOTREACHED();
return String();
}
v8::Local<v8::Value> toV8(const TestInterfaceGarbageCollectedOrString& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate) {
switch (impl.m_type) {
case TestInterfaceGarbageCollectedOrString::SpecificTypeNone:
return v8::Null(isolate);
case TestInterfaceGarbageCollectedOrString::SpecificTypeTestInterfaceGarbageCollected:
return toV8(impl.getAsTestInterfaceGarbageCollected(), creationContext, isolate);
case TestInterfaceGarbageCollectedOrString::SpecificTypeString:
return v8String(isolate, impl.getAsString());
default:
NOTREACHED();
}
return v8::Local<v8::Value>();
}
String SecurityContext::addressSpaceForBindings() const {
switch (m_addressSpace) {
case WebAddressSpacePublic:
return "public";
case WebAddressSpacePrivate:
return "private";
case WebAddressSpaceLocal:
return "local";
}
NOTREACHED();
return "public";
}
IClusterSPtr ServersManager::createCluster(IClusterSettingsBaseSPtr settings) {
if (!settings) {
NOTREACHED();
return IClusterSPtr();
}
connectionTypes conT = settings->type();
#ifdef BUILD_WITH_REDIS
if (conT == REDIS) {
IClusterSPtr cl(new redis::RedisCluster(settings->name()));
IClusterSettingsBase::cluster_connection_type nodes = settings->nodes();
for (size_t i = 0; i < nodes.size(); ++i) {
IConnectionSettingsBaseSPtr nd = nodes[i];
IServerSPtr serv = createServer(nd);
cl->addServer(serv);
}
return cl;
}
#endif
NOTREACHED();
return IClusterSPtr();
}
String MediaStreamTrack::kind() const {
DEFINE_STATIC_LOCAL(String, audioKind, ("audio"));
DEFINE_STATIC_LOCAL(String, videoKind, ("video"));
switch (m_component->source()->type()) {
case MediaStreamSource::TypeAudio:
return audioKind;
case MediaStreamSource::TypeVideo:
return videoKind;
}
NOTREACHED();
return audioKind;
}
TestPlugin::Primitive TestPlugin::parsePrimitive(const WebString& string)
{
const CR_DEFINE_STATIC_LOCAL(WebString, kPrimitiveNone, ("none"));
const CR_DEFINE_STATIC_LOCAL(WebString, kPrimitiveTriangle, ("triangle"));
Primitive primitive = PrimitiveNone;
if (string == kPrimitiveNone)
primitive = PrimitiveNone;
else if (string == kPrimitiveTriangle)
primitive = PrimitiveTriangle;
else
NOTREACHED();
return primitive;
}
bool NativeTextfieldWin::IsCommandIdEnabled(int command_id) const
{
switch(command_id)
{
case IDS_APP_UNDO: return !textfield_->read_only() && !!CanUndo();
case IDS_APP_CUT: return !textfield_->read_only() &&
!textfield_->IsPassword() && !!CanCut();
case IDS_APP_COPY: return !!CanCopy() && !textfield_->IsPassword();
case IDS_APP_PASTE: return !textfield_->read_only() && !!CanPaste();
case IDS_APP_SELECT_ALL: return !!CanSelectAll();
default: NOTREACHED();
return false;
}
}
FilterOperation* FilterInterpolationFunctions::createFilter(
const InterpolableValue& interpolableValue,
const NonInterpolableValue& untypedNonInterpolableValue,
const StyleResolverState& state) {
const FilterNonInterpolableValue& nonInterpolableValue =
toFilterNonInterpolableValue(untypedNonInterpolableValue);
FilterOperation::OperationType type = nonInterpolableValue.type();
switch (type) {
case FilterOperation::GRAYSCALE:
case FilterOperation::HUE_ROTATE:
case FilterOperation::SATURATE:
case FilterOperation::SEPIA: {
double value =
clampParameter(toInterpolableNumber(interpolableValue).value(), type);
return BasicColorMatrixFilterOperation::create(value, type);
}
case FilterOperation::BRIGHTNESS:
case FilterOperation::CONTRAST:
case FilterOperation::INVERT:
case FilterOperation::OPACITY: {
double value =
clampParameter(toInterpolableNumber(interpolableValue).value(), type);
return BasicComponentTransferFilterOperation::create(value, type);
}
case FilterOperation::BLUR: {
Length stdDeviation = LengthInterpolationFunctions::createLength(
interpolableValue, nonInterpolableValue.typeNonInterpolableValue(),
state.cssToLengthConversionData(), ValueRangeNonNegative);
return BlurFilterOperation::create(stdDeviation);
}
case FilterOperation::DROP_SHADOW: {
ShadowData shadowData = ShadowInterpolationFunctions::createShadowData(
interpolableValue, nonInterpolableValue.typeNonInterpolableValue(),
state);
Color color = shadowData.color().isCurrentColor()
? Color::black
: shadowData.color().getColor();
return DropShadowFilterOperation::create(
IntPoint(shadowData.x(), shadowData.y()), shadowData.blur(), color);
}
default:
NOTREACHED();
return nullptr;
}
}
void FieldTrial::UseOneTimeRandomization()
{
DCHECK_EQ(group_, kNotFinalized);
DCHECK_EQ(kDefaultGroupNumber + 1, next_group_number_);
if(!FieldTrialList::IsOneTimeRandomizationEnabled())
{
NOTREACHED();
Disable();
return;
}
random_ = static_cast<Probability>(
divisor_ * HashClientId(FieldTrialList::client_id(), name_));
}
String Notification::permissionString(
mojom::blink::PermissionStatus permission) {
switch (permission) {
case mojom::blink::PermissionStatus::GRANTED:
return "granted";
case mojom::blink::PermissionStatus::DENIED:
return "denied";
case mojom::blink::PermissionStatus::ASK:
return "default";
}
NOTREACHED();
return "denied";
}
String MediaDeviceInfo::kind() const
{
switch (m_webMediaDeviceInfo.kind()) {
case WebMediaDeviceInfo::MediaDeviceKindAudioInput:
return "audioinput";
case WebMediaDeviceInfo::MediaDeviceKindAudioOutput:
return "audiooutput";
case WebMediaDeviceInfo::MediaDeviceKindVideoInput:
return "videoinput";
}
NOTREACHED();
return String();
}
WebNavigationType WebPerformance::navigationType() const {
switch (m_private->navigation()->type()) {
case PerformanceNavigation::kTypeNavigate:
return WebNavigationTypeOther;
case PerformanceNavigation::kTypeReload:
return WebNavigationTypeReload;
case PerformanceNavigation::kTypeBackForward:
return WebNavigationTypeBackForward;
case PerformanceNavigation::kTypeReserved:
return WebNavigationTypeOther;
}
NOTREACHED();
return WebNavigationTypeOther;
}
unsigned PropertyHandle::hash() const
{
switch (m_handleType) {
case HandleCSSProperty:
return m_cssProperty;
case HandlePresentationAttribute:
return -m_cssProperty;
case HandleSVGAttribute:
return QualifiedNameHash::hash(*m_svgAttribute);
default:
NOTREACHED();
return 0;
}
}
inline static PassRefPtr<AnimatableValue> createFromFillSize(const FillSize& fillSize, const ComputedStyle& style)
{
switch (fillSize.type) {
case SizeLength:
return createFromLengthSize(fillSize.size, style);
case Contain:
case Cover:
case SizeNone:
return AnimatableUnknown::create(CSSPrimitiveValue::create(fillSize.type));
default:
NOTREACHED();
return nullptr;
}
}
gfx::Rect GetMonitorBoundsForRect(const gfx::Rect& rect)
{
RECT p_rect = rect.ToRECT();
HMONITOR monitor = MonitorFromRect(&p_rect, MONITOR_DEFAULTTONEAREST);
if(monitor)
{
MONITORINFO mi = { 0 };
mi.cbSize = sizeof(mi);
GetMonitorInfo(monitor, &mi);
return gfx::Rect(mi.rcWork);
}
NOTREACHED();
return gfx::Rect();
}
void CPDF_FileSpec::SetFileName(const WideString& wsFileName) {
if (!m_pWritableObj) {
NOTREACHED();
return;
}
WideString wsStr = EncodeFileName(wsFileName);
if (m_pObj->IsString()) {
m_pWritableObj->SetString(wsStr.ToDefANSI());
} else if (CPDF_Dictionary* pDict = m_pWritableObj->AsDictionary()) {
pDict->SetNewFor<CPDF_String>(pdfium::stream::kF, wsStr.ToDefANSI(), false);
pDict->SetNewFor<CPDF_String>("UF", PDF_EncodeText(wsStr), false);
}
}
