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); } }