ImageData* ImageData::create(DOMUint8ClampedArray* data, unsigned width, ExceptionState& exceptionState) { unsigned lengthInPixels = 0; if (!validateConstructorArguments(data, width, lengthInPixels, exceptionState)) { DCHECK(exceptionState.hadException()); return nullptr; } DCHECK_GT(lengthInPixels, 0u); DCHECK_GT(width, 0u); unsigned height = lengthInPixels / width; return new ImageData(IntSize(width, height), data); }
void NodeSet::traversalSort() const { HeapHashSet<Member<Node>> nodes; bool containsAttributeNodes = false; unsigned nodeCount = m_nodes.size(); DCHECK_GT(nodeCount, 1u); for (unsigned i = 0; i < nodeCount; ++i) { Node* node = m_nodes[i].get(); nodes.add(node); if (node->isAttributeNode()) containsAttributeNodes = true; } HeapVector<Member<Node>> sortedNodes; sortedNodes.reserveInitialCapacity(nodeCount); for (Node& n : NodeTraversal::startsAt(*findRootNode(m_nodes.first()))) { if (nodes.contains(&n)) sortedNodes.append(&n); if (!containsAttributeNodes || !n.isElementNode()) continue; Element* element = toElement(&n); AttributeCollection attributes = element->attributes(); for (auto& attribute : attributes) { Attr* attr = element->attrIfExists(attribute.name()); if (attr && nodes.contains(attr)) sortedNodes.append(attr); } } DCHECK_EQ(sortedNodes.size(), nodeCount); const_cast<HeapVector<Member<Node>>&>(m_nodes).swap(sortedNodes); }
SplitTextNodeContainingElementCommand::SplitTextNodeContainingElementCommand( Text* text, int offset) : CompositeEditCommand(text->document()), m_text(text), m_offset(offset) { DCHECK(m_text); DCHECK_GT(m_text->length(), 0u); }
size_t HTTPTransaction::sendBodyNow(std::unique_ptr<folly::IOBuf> body, size_t bodyLen, bool sendEom) { static const std::string noneStr = "None"; DCHECK(body); DCHECK_GT(bodyLen, 0); size_t nbytes = 0; if (useFlowControl_) { CHECK(sendWindow_.reserve(bodyLen)); } VLOG(4) << *this << " Sending " << bodyLen << " bytes of body. eom=" << ((sendEom) ? "yes" : "no") << " send_window is " << ( useFlowControl_ ? folly::to<std::string>(sendWindow_.getSize(), " / ", sendWindow_.getCapacity()) : noneStr); if (sendEom) { CHECK(HTTPTransactionEgressSM::transit( egressState_, HTTPTransactionEgressSM::Event::eomFlushed)); } else if (ingressErrorSeen_ && isExpectingWindowUpdate()) { // I don't know how we got here but we're in trouble. We need a window // update to continue but we've already seen an ingress error. HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS, folly::to<std::string>("window blocked with ingress error," " streamID=", id_)); ex.setProxygenError(kErrorEOF); ex.setCodecStatusCode(ErrorCode::FLOW_CONTROL_ERROR); onError(ex); return 0; } updateReadTimeout(); nbytes = transport_.sendBody(this, std::move(body), sendEom); if (egressLimitBytesPerMs_ > 0) { numLimitedBytesEgressed_ += nbytes; } return nbytes; }
/** * @brief Constructor for merging sorted runs to generate a sorted relation. * * @param input_relation The relation to merge sorted blocks. * @param output_relation The output relation. * @param output_destination_index The index of the InsertDestination in the * QueryContext to store the sorted blocks in. * @param run_relation The temporary relation used to store intermediate runs * of blocks. * @param run_block_destination_index The index of the InsertDestination in * the QueryContext to store the intermediate blocks in the merging * process. * @param sort_config_index The index of the Sort configuration in * QueryContext. * @param merge_factor Merge factor of this operator. * @param top_k Only return the first \c top_k results. Return all results if * \c top_k is 0. * @param input_relation_is_stored Boolean to indicate is input relation is * stored or streamed. **/ SortMergeRunOperator(const CatalogRelation &input_relation, const CatalogRelation &output_relation, const QueryContext::insert_destination_id output_destination_index, const CatalogRelation &run_relation, const QueryContext::insert_destination_id run_block_destination_index, const QueryContext::sort_config_id sort_config_index, const std::size_t merge_factor, const std::size_t top_k, const bool input_relation_is_stored) : input_relation_(input_relation), output_relation_(output_relation), output_destination_index_(output_destination_index), sort_config_index_(sort_config_index), merge_factor_(merge_factor), top_k_(top_k), merge_tree_(merge_factor_), input_relation_block_ids_(input_relation_is_stored ? input_relation.getBlocksSnapshot() : std::vector<block_id>()), num_input_workorders_generated_(0), run_relation_(run_relation), run_block_destination_index_(run_block_destination_index), input_relation_is_stored_(input_relation_is_stored), input_stream_done_(input_relation_is_stored), started_(false) { DCHECK_GT(merge_factor_, 1u); }
bool PathService::Override(int key, const FilePath& path) { PathData* path_data = GetPathData(); DCHECK(path_data); DCHECK_GT(key, base::DIR_CURRENT) << "invalid path key"; FilePath file_path = path; // Make sure the directory exists. We need to do this before we translate // this to the absolute path because on POSIX, AbsolutePath fails if called // on a non-existant path. if(!base::PathExists(file_path) && !base::CreateDirectory(file_path)) { return false; } // We need to have an absolute path, as extensions and plugins don't like // relative paths, and will glady crash the browser in CHECK()s if they get a // relative path. if(!base::AbsolutePath(&file_path)) { return false; } base::AutoLock scoped_lock(path_data->lock); // Clear the cache now. Some of its entries could have depended // on the value we are overriding, and are now out of sync with reality. path_data->cache.clear(); path_data->cache[key] = file_path; path_data->overrides[key] = file_path; return true; }
void PathService::RegisterProvider(ProviderFunc func, int key_start, int key_end) { PathData* path_data = GetPathData(); DCHECK(path_data); DCHECK_GT(key_end, key_start); base::AutoLock scoped_lock(path_data->lock); Provider* p; #ifndef NDEBUG p = path_data->providers; while(p) { DCHECK(key_start >= p->key_end || key_end <= p->key_start) << "path provider collision"; p = p->next; } #endif p = new Provider; p->is_static = false; p->func = func; p->next = path_data->providers; #ifndef NDEBUG p->key_start = key_start; p->key_end = key_end; #endif path_data->providers = p; }
/* * Copy "len" bytes from "src" to "op", one byte at a time. Used for * handling COPY operations where the input and output regions may * overlap. For example, suppose: * src == "ab" * op == src + 2 * len == 20 * After IncrementalCopy(src, op, len), the result will have * eleven copies of "ab" * ababababababababababab * Note that this does not match the semantics of either memcpy() * or memmove(). */ static inline void IncrementalCopy(const char *src, char *op, int len) { DCHECK_GT(len, 0); do { *op++ = *src++; } while (--len > 0); }
BytesWriteHandler::BytesWriteHandler(size_t grow) : grow_(grow), datasize_(grow), offset_(0) { DCHECK_GT(grow, 0U); data_ = malloc(grow); DCHECK(data_ != NULL); }
ImageBuffer::~ImageBuffer() { if (m_gpuMemoryUsage) { DCHECK_GT(s_globalAcceleratedImageBufferCount, 0u); s_globalAcceleratedImageBufferCount--; } ImageBuffer::s_globalGPUMemoryUsage -= m_gpuMemoryUsage; }
void NotificationResourcesLoader::didFinishRequest() { DCHECK_GT(m_pendingRequestCount, 0); m_pendingRequestCount--; if (!m_pendingRequestCount) { stop(); (*m_completionCallback)(this); // The |this| pointer may have been deleted now. } }
inline std::size_t reduceEstimatedCardinality( const std::size_t original_estimate) const { if (original_estimate < kEstimateReductionFactor) { return original_estimate; } else { DCHECK_GT(kEstimateReductionFactor, 0u); return original_estimate / kEstimateReductionFactor; } }
/** * @brief Add a mapping between a block and the NUMA node on which the block * is placed. * * @param block The block_id of the block for which the NUMA node mapping is * added. * @param numa_node The numa node id on which the block is placed. **/ void addBlockToNUMANodeMap(const block_id block, const int numa_node) { // Make sure that the block doesn't have a mapping already. // A block will be mapped to only one NUMA node. // A NUMA node will be associated with a block only once. DCHECK(block_to_numa_node_map_.find(block) == block_to_numa_node_map_.end()); DCHECK_GT(numa_num_configured_nodes(), numa_node) << "NUMA node above the valid value."; block_to_numa_node_map_[block] = numa_node; }
CachedMetadata::CachedMetadata(const char* data, size_t size) { // We need to define a local variable to use the constant in DCHECK. constexpr auto kDataStart = CachedMetadata::kDataStart; // Serialized metadata should have non-empty data. DCHECK_GT(size, kDataStart); DCHECK(data); m_serializedData.reserveInitialCapacity(size); m_serializedData.append(data, size); }
IIRProcessor::IIRProcessor(float sampleRate, size_t numberOfChannels, const Vector<double>& feedforwardCoef, const Vector<double>& feedbackCoef) : AudioDSPKernelProcessor(sampleRate, numberOfChannels) { unsigned feedbackLength = feedbackCoef.size(); unsigned feedforwardLength = feedforwardCoef.size(); DCHECK_GT(feedbackLength, 0u); DCHECK_GT(feedforwardLength, 0u); m_feedforward.allocate(feedforwardLength); m_feedback.allocate(feedbackLength); m_feedforward.copyToRange(feedforwardCoef.data(), 0, feedforwardLength); m_feedback.copyToRange(feedbackCoef.data(), 0, feedbackLength); // Need to scale the feedback and feedforward coefficients appropriately. // (It's up to the caller to ensure feedbackCoef[0] is not 0.) DCHECK_NE(feedbackCoef[0], 0); if (feedbackCoef[0] != 1) { // The provided filter is: // // a[0]*y(n) + a[1]*y(n-1) + ... = b[0]*x(n) + b[1]*x(n-1) + ... // // We want the leading coefficient of y(n) to be 1: // // y(n) + a[1]/a[0]*y(n-1) + ... = b[0]/a[0]*x(n) + b[1]/a[0]*x(n-1) + ... // // Thus, the feedback and feedforward coefficients need to be scaled by // 1/a[0]. float scale = feedbackCoef[0]; for (unsigned k = 1; k < feedbackLength; ++k) m_feedback[k] /= scale; for (unsigned k = 0; k < feedforwardLength; ++k) m_feedforward[k] /= scale; // The IIRFilter checks to make sure this coefficient is 1, so make it so. m_feedback[0] = 1; } m_responseKernel = WTF::makeUnique<IIRDSPKernel>(this); }
FieldTrial::FieldTrial(const std::string& name, const Probability total_probability, const std::string& default_group_name, const int year, const int month, const int day_of_month) : name_(name), divisor_(total_probability), default_group_name_(default_group_name), random_(static_cast<Probability>(divisor_*RandDouble())), accumulated_group_probability_(0), next_group_number_(kDefaultGroupNumber+1), group_(kNotFinalized), enable_field_trial_(true) { DCHECK_GT(total_probability, 0); DCHECK(!name_.empty()); DCHECK(!default_group_name_.empty()); FieldTrialList::Register(this); DCHECK_GT(year, 1970); DCHECK_GT(month, 0); DCHECK_LT(month, 13); DCHECK_GT(day_of_month, 0); DCHECK_LT(day_of_month, 32); Time::Exploded exploded; exploded.year = year; exploded.month = month; exploded.day_of_week = 0; // Should be unused. exploded.day_of_month = day_of_month; exploded.hour = 0; exploded.minute = 0; exploded.second = 0; exploded.millisecond = 0; Time expiration_time = Time::FromLocalExploded(exploded); if(GetBuildTime() > expiration_time) { Disable(); } }
ImageData* ImageData::create(DOMUint8ClampedArray* data, unsigned width, unsigned height, ExceptionState& exceptionState) { unsigned lengthInPixels = 0; if (!validateConstructorArguments(data, width, lengthInPixels, exceptionState)) { DCHECK(exceptionState.hadException()); return nullptr; } DCHECK_GT(lengthInPixels, 0u); DCHECK_GT(width, 0u); if (height != lengthInPixels / width) { exceptionState.throwDOMException( IndexSizeError, "The input data byte length is not equal to (4 * width * height)."); return nullptr; } return new ImageData(IntSize(width, height), data); }
ProcessReturnCode Subprocess::poll() { returnCode_.enforce(ProcessReturnCode::RUNNING); DCHECK_GT(pid_, 0); int status; pid_t found = ::waitpid(pid_, &status, WNOHANG); checkUnixError(found, "waitpid"); if (found != 0) { returnCode_ = ProcessReturnCode(status); pid_ = -1; } return returnCode_; }
std::unique_ptr<IOBuf> ZlibStreamDecompressor::decompress(const IOBuf* in) { auto out = IOBuf::create(decompressor_buffer_growth_); auto appender = folly::io::Appender(out.get(), decompressor_buffer_growth_); const IOBuf* crtBuf = in; size_t offset = 0; while (true) { // Advance to the next IOBuf if necessary DCHECK_GE(crtBuf->length(), offset); if (crtBuf->length() == offset) { crtBuf = crtBuf->next(); offset = 0; if (crtBuf == in) { // We hit the end of the IOBuf chain, and are done. break; } } if (status_ == Z_STREAM_END) { // we convert this into a stream error status_ = Z_STREAM_ERROR; // we should probably bump up a counter here LOG(ERROR) << "error uncompressing buffer: reached end of zlib data " "before the end of the buffer"; return nullptr; } // Ensure there is space in the output IOBuf appender.ensure(decompressor_buffer_minsize_); DCHECK_GT(appender.length(), 0); const size_t origAvailIn = crtBuf->length() - offset; zlibStream_.next_in = const_cast<uint8_t*>(crtBuf->data() + offset); zlibStream_.avail_in = origAvailIn; zlibStream_.next_out = appender.writableData(); zlibStream_.avail_out = appender.length(); status_ = inflate(&zlibStream_, Z_PARTIAL_FLUSH); if (status_ != Z_OK && status_ != Z_STREAM_END) { LOG(INFO) << "error uncompressing buffer: r=" << status_; return nullptr; } // Adjust the input offset ahead auto inConsumed = origAvailIn - zlibStream_.avail_in; offset += inConsumed; // Move output buffer ahead auto outMove = appender.length() - zlibStream_.avail_out; appender.append(outMove); } return out; }
ProcessReturnCode Subprocess::wait() { returnCode_.enforce(ProcessReturnCode::RUNNING); DCHECK_GT(pid_, 0); int status; pid_t found; do { found = ::waitpid(pid_, &status, 0); } while (found == -1 && errno == EINTR); checkUnixError(found, "waitpid"); DCHECK_EQ(found, pid_); returnCode_ = ProcessReturnCode(status); return returnCode_; }
void RadioButtonGroup::updateRequiredButton(MemberKeyValue& it, bool isRequired) { if (it.value == isRequired) return; it.value = isRequired; if (isRequired) { m_requiredCount++; } else { DCHECK_GT(m_requiredCount, 0u); m_requiredCount--; } }
// helper method for case where needles.size() <= 16 size_t qfind_first_byte_of_needles16(const StringPieceLite haystack, const StringPieceLite needles) { DCHECK_GT(haystack.size(), 0u); DCHECK_GT(needles.size(), 0u); DCHECK_LE(needles.size(), 16u); if ((needles.size() <= 2 && haystack.size() >= 256) || // must bail if we can't even SSE-load a single segment of haystack (haystack.size() < 16 && page_for(haystack.end() - 1) != page_for(haystack.data() + 15)) || // can't load needles into SSE register if it could cross page boundary page_for(needles.end() - 1) != page_for(needles.data() + 15)) { return detail::qfind_first_byte_of_nosse(haystack, needles); } auto arr2 = _mm_loadu_si128( reinterpret_cast<const __m128i*>(needles.data())); // do an unaligned load for first block of haystack auto arr1 = _mm_loadu_si128( reinterpret_cast<const __m128i*>(haystack.data())); auto index = _mm_cmpestri(arr2, int(needles.size()), arr1, int(haystack.size()), 0); if (index < 16) { return index; } // Now, we can do aligned loads hereafter... size_t i = nextAlignedIndex(haystack.data()); for (; i < haystack.size(); i+= 16) { arr1 = _mm_load_si128(reinterpret_cast<const __m128i*>(haystack.data() + i)); index = _mm_cmpestri( arr2, int(needles.size()), arr1, int(haystack.size() - i), 0); if (index < 16) { return i + index; } } return std::string::npos; }
ProcessReturnCode Subprocess::poll() { returnCode_.enforce(ProcessReturnCode::RUNNING); DCHECK_GT(pid_, 0); int status; pid_t found = ::waitpid(pid_, &status, WNOHANG); checkUnixError(found, "waitpid"); if (found != 0) { // Though the child process had quit, this call does not close the pipes // since its descendants may still be using them. returnCode_ = ProcessReturnCode(status); pid_ = -1; } return returnCode_; }
static CString encodeComplexWindowsLatin1(const CharType* characters, size_t length, UnencodableHandling handling) { size_t targetLength = length; Vector<char> result(targetLength); char* bytes = result.data(); size_t resultLength = 0; for (size_t i = 0; i < length;) { UChar32 c; // If CharType is LChar the U16_NEXT call reads a byte and increments; // since the convention is that LChar is already latin1 this is safe. U16_NEXT(characters, i, length, c); // If input was a surrogate pair (non-BMP character) then we overestimated // the length. if (c > 0xffff) --targetLength; unsigned char b = static_cast<unsigned char>(c); // Do an efficient check to detect characters other than 00-7F and A0-FF. if (b != c || (c & 0xE0) == 0x80) { // Look for a way to encode this with Windows Latin-1. for (b = 0x80; b < 0xA0; ++b) { if (table[b] == c) goto gotByte; } // No way to encode this character with Windows Latin-1. UnencodableReplacementArray replacement; int replacementLength = TextCodec::getUnencodableReplacement(c, handling, replacement); DCHECK_GT(replacementLength, 0); // Only one char was initially reserved per input character, so grow if // necessary. Note that the case of surrogate pairs and // QuestionMarksForUnencodables the result length may be shorter than // the input length. targetLength += replacementLength - 1; if (targetLength > result.size()) { result.grow(targetLength); bytes = result.data(); } memcpy(bytes + resultLength, replacement, replacementLength); resultLength += replacementLength; continue; } gotByte: bytes[resultLength++] = b; } return CString(bytes, resultLength); }
ProcessReturnCode Subprocess::wait() { returnCode_.enforce(ProcessReturnCode::RUNNING); DCHECK_GT(pid_, 0); int status; pid_t found; do { found = ::waitpid(pid_, &status, 0); } while (found == -1 && errno == EINTR); checkUnixError(found, "waitpid"); // Though the child process had quit, this call does not close the pipes // since its descendants may still be using them. DCHECK_EQ(found, pid_); returnCode_ = ProcessReturnCode(status); pid_ = -1; return returnCode_; }
void CanvasRenderingContext2D::validateStateStack() const { #if DCHECK_IS_ON() if (SkCanvas* skCanvas = canvas()->existingDrawingCanvas()) { // The canvas should always have an initial save frame, to support // resetting the top level matrix and clip. DCHECK_GT(skCanvas->getSaveCount(), 1); if (m_contextLostMode == NotLostContext) { DCHECK_EQ(static_cast<size_t>(skCanvas->getSaveCount()), m_stateStack.size() + 1); } } #endif CHECK(m_stateStack.first() .get()); // Temporary for investigating crbug.com/648510 }
string ToZeroPaddedString(std::uint64_t val, int pad_width) { DCHECK_GT(pad_width, 0); const std::size_t str_len = pad_width + 1; char *str = new char[str_len](); int bytes = snprintf(str, str_len, "%0*" PRIu64, pad_width, val); DCHECK_EQ(pad_width, bytes); string result(str, pad_width); delete[] str; return result; }
uint64 RandGenerator(uint64 range) { DCHECK_GT(range, 0u); // We must discard random results above this number, as they would // make the random generator non-uniform (consider e.g. if // MAX_UINT64 was 7 and |range| was 5, then a result of 1 would be twice // as likely as a result of 3 or 4). uint64 max_acceptable_value = (std::numeric_limits<uint64>::max() / range) * range - 1; uint64 value; do { value = base::RandUint64(); } while(value >= max_acceptable_value); return value % range; }
size_t scanHaystackBlock(const StringPieceLite haystack, const StringPieceLite needles, uint64_t blockStartIdx) { DCHECK_GT(needles.size(), 16u); // should handled by *needles16() method DCHECK(blockStartIdx + 16 <= haystack.size() || (page_for(haystack.data() + blockStartIdx) == page_for(haystack.data() + blockStartIdx + 15))); __m128i arr1; if (HAYSTACK_ALIGNED) { arr1 = _mm_load_si128( reinterpret_cast<const __m128i*>(haystack.data() + blockStartIdx)); } else { arr1 = _mm_loadu_si128( reinterpret_cast<const __m128i*>(haystack.data() + blockStartIdx)); } // This load is safe because needles.size() >= 16 auto arr2 = _mm_loadu_si128( reinterpret_cast<const __m128i*>(needles.data())); size_t b = _mm_cmpestri(arr2, 16, arr1, int(haystack.size() - blockStartIdx), 0); size_t j = nextAlignedIndex(needles.data()); for (; j < needles.size(); j += 16) { arr2 = _mm_load_si128( reinterpret_cast<const __m128i*>(needles.data() + j)); auto index = _mm_cmpestri( arr2, int(needles.size() - j), arr1, int(haystack.size() - blockStartIdx), 0); b = std::min<size_t>(index, b); } if (b < 16) { return blockStartIdx + b; } return std::string::npos; }
bool IOBufEqual::operator()(const IOBuf& a, const IOBuf& b) const { io::Cursor ca(&a); io::Cursor cb(&b); for (;;) { auto ba = ca.peekBytes(); auto bb = cb.peekBytes(); if (ba.empty() && bb.empty()) { return true; } else if (ba.empty() || bb.empty()) { return false; } size_t n = std::min(ba.size(), bb.size()); DCHECK_GT(n, 0u); if (memcmp(ba.data(), bb.data(), n)) { return false; } ca.skip(n); cb.skip(n); } }