unique_id
int64 13
189k
| target
int64 0
1
| code
stringlengths 20
241k
| __index_level_0__
int64 0
18.9k
|
|---|---|---|---|
86,627 | 0 |
struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q,
int node, int cmd_size)
{
struct blk_flush_queue *fq;
int rq_sz = sizeof(struct request);
fq = kzalloc_node(sizeof(*fq), GFP_KERNEL, node);
if (!fq)
goto fail;
if (q->mq_ops) {
spin_lock_init(&fq->mq_flush_lock);
rq_sz = round_up(rq_sz + cmd_size, cache_line_size());
}
fq->flush_rq = kzalloc_node(rq_sz, GFP_KERNEL, node);
if (!fq->flush_rq)
goto fail_rq;
INIT_LIST_HEAD(&fq->flush_queue[0]);
INIT_LIST_HEAD(&fq->flush_queue[1]);
INIT_LIST_HEAD(&fq->flush_data_in_flight);
return fq;
fail_rq:
kfree(fq);
fail:
return NULL;
}
| 5,700 |
142,546 | 0 |
ShelfWidget::GetDragAndDropHostForAppList() {
return shelf_view_;
}
| 5,701 |
10,237 | 0 |
FT_Get_CMap_Language_ID( FT_CharMap charmap )
{
FT_Service_TTCMaps service;
FT_Face face;
TT_CMapInfo cmap_info;
if ( !charmap || !charmap->face )
return 0;
face = charmap->face;
FT_FACE_FIND_SERVICE( face, service, TT_CMAP );
if ( service == NULL )
return 0;
if ( service->get_cmap_info( charmap, &cmap_info ))
return 0;
return cmap_info.language;
}
| 5,702 |
67,183 | 0 |
static struct mempolicy *mpol_new(unsigned short mode, unsigned short flags,
nodemask_t *nodes)
{
struct mempolicy *policy;
pr_debug("setting mode %d flags %d nodes[0] %lx\n",
mode, flags, nodes ? nodes_addr(*nodes)[0] : NUMA_NO_NODE);
if (mode == MPOL_DEFAULT) {
if (nodes && !nodes_empty(*nodes))
return ERR_PTR(-EINVAL);
return NULL;
}
VM_BUG_ON(!nodes);
/*
* MPOL_PREFERRED cannot be used with MPOL_F_STATIC_NODES or
* MPOL_F_RELATIVE_NODES if the nodemask is empty (local allocation).
* All other modes require a valid pointer to a non-empty nodemask.
*/
if (mode == MPOL_PREFERRED) {
if (nodes_empty(*nodes)) {
if (((flags & MPOL_F_STATIC_NODES) ||
(flags & MPOL_F_RELATIVE_NODES)))
return ERR_PTR(-EINVAL);
}
} else if (mode == MPOL_LOCAL) {
if (!nodes_empty(*nodes) ||
(flags & MPOL_F_STATIC_NODES) ||
(flags & MPOL_F_RELATIVE_NODES))
return ERR_PTR(-EINVAL);
mode = MPOL_PREFERRED;
} else if (nodes_empty(*nodes))
return ERR_PTR(-EINVAL);
policy = kmem_cache_alloc(policy_cache, GFP_KERNEL);
if (!policy)
return ERR_PTR(-ENOMEM);
atomic_set(&policy->refcnt, 1);
policy->mode = mode;
policy->flags = flags;
return policy;
}
| 5,703 |
60,175 | 0 |
R_API int r_bin_is_static(RBin *bin) {
RBinObject *o = r_bin_cur_object (bin);
if (o && r_list_length (o->libs) > 0)
return R_BIN_DBG_STATIC & o->info->dbg_info;
return true;
}
| 5,704 |
21,375 | 0 |
int add_swap_count_continuation(swp_entry_t entry, gfp_t gfp_mask)
{
struct swap_info_struct *si;
struct page *head;
struct page *page;
struct page *list_page;
pgoff_t offset;
unsigned char count;
/*
* When debugging, it's easier to use __GFP_ZERO here; but it's better
* for latency not to zero a page while GFP_ATOMIC and holding locks.
*/
page = alloc_page(gfp_mask | __GFP_HIGHMEM);
si = swap_info_get(entry);
if (!si) {
/*
* An acceptable race has occurred since the failing
* __swap_duplicate(): the swap entry has been freed,
* perhaps even the whole swap_map cleared for swapoff.
*/
goto outer;
}
offset = swp_offset(entry);
count = si->swap_map[offset] & ~SWAP_HAS_CACHE;
if ((count & ~COUNT_CONTINUED) != SWAP_MAP_MAX) {
/*
* The higher the swap count, the more likely it is that tasks
* will race to add swap count continuation: we need to avoid
* over-provisioning.
*/
goto out;
}
if (!page) {
spin_unlock(&swap_lock);
return -ENOMEM;
}
/*
* We are fortunate that although vmalloc_to_page uses pte_offset_map,
* no architecture is using highmem pages for kernel pagetables: so it
* will not corrupt the GFP_ATOMIC caller's atomic pagetable kmaps.
*/
head = vmalloc_to_page(si->swap_map + offset);
offset &= ~PAGE_MASK;
/*
* Page allocation does not initialize the page's lru field,
* but it does always reset its private field.
*/
if (!page_private(head)) {
BUG_ON(count & COUNT_CONTINUED);
INIT_LIST_HEAD(&head->lru);
set_page_private(head, SWP_CONTINUED);
si->flags |= SWP_CONTINUED;
}
list_for_each_entry(list_page, &head->lru, lru) {
unsigned char *map;
/*
* If the previous map said no continuation, but we've found
* a continuation page, free our allocation and use this one.
*/
if (!(count & COUNT_CONTINUED))
goto out;
map = kmap_atomic(list_page, KM_USER0) + offset;
count = *map;
kunmap_atomic(map, KM_USER0);
/*
* If this continuation count now has some space in it,
* free our allocation and use this one.
*/
if ((count & ~COUNT_CONTINUED) != SWAP_CONT_MAX)
goto out;
}
list_add_tail(&page->lru, &head->lru);
page = NULL; /* now it's attached, don't free it */
out:
spin_unlock(&swap_lock);
outer:
if (page)
__free_page(page);
return 0;
}
| 5,705 |
173,651 | 0 |
void ATSParser::PSISection::clear() {
if (mBuffer != NULL) {
mBuffer->setRange(0, 0);
}
mSkipBytes = 0;
}
| 5,706 |
10,145 | 0 |
Ins_OR( INS_ARG )
{
DO_OR
}
| 5,707 |
9,635 | 0 |
static int php_session_rfc1867_callback(unsigned int event, void *event_data, void **extra TSRMLS_DC) /* {{{ */
{
php_session_rfc1867_progress *progress;
int retval = SUCCESS;
if (php_session_rfc1867_orig_callback) {
retval = php_session_rfc1867_orig_callback(event, event_data, extra TSRMLS_CC);
}
if (!PS(rfc1867_enabled)) {
return retval;
}
progress = PS(rfc1867_progress);
switch(event) {
case MULTIPART_EVENT_START: {
multipart_event_start *data = (multipart_event_start *) event_data;
progress = ecalloc(1, sizeof(php_session_rfc1867_progress));
progress->content_length = data->content_length;
progress->sname_len = strlen(PS(session_name));
PS(rfc1867_progress) = progress;
}
break;
case MULTIPART_EVENT_FORMDATA: {
multipart_event_formdata *data = (multipart_event_formdata *) event_data;
size_t value_len;
if (Z_TYPE(progress->sid) && progress->key.c) {
break;
}
/* orig callback may have modified *data->newlength */
if (data->newlength) {
value_len = *data->newlength;
} else {
value_len = data->length;
}
if (data->name && data->value && value_len) {
size_t name_len = strlen(data->name);
if (name_len == progress->sname_len && memcmp(data->name, PS(session_name), name_len) == 0) {
zval_dtor(&progress->sid);
ZVAL_STRINGL(&progress->sid, (*data->value), value_len, 1);
} else if (name_len == PS(rfc1867_name).len && memcmp(data->name, PS(rfc1867_name).c, name_len) == 0) {
smart_str_free(&progress->key);
smart_str_appendl(&progress->key, PS(rfc1867_prefix).c, PS(rfc1867_prefix).len);
smart_str_appendl(&progress->key, *data->value, value_len);
smart_str_0(&progress->key);
progress->apply_trans_sid = PS(use_trans_sid);
php_session_rfc1867_early_find_sid(progress TSRMLS_CC);
}
}
}
break;
case MULTIPART_EVENT_FILE_START: {
multipart_event_file_start *data = (multipart_event_file_start *) event_data;
/* Do nothing when $_POST["PHP_SESSION_UPLOAD_PROGRESS"] is not set
* or when we have no session id */
if (!Z_TYPE(progress->sid) || !progress->key.c) {
break;
}
/* First FILE_START event, initializing data */
if (!progress->data) {
if (PS(rfc1867_freq) >= 0) {
progress->update_step = PS(rfc1867_freq);
} else if (PS(rfc1867_freq) < 0) { /* % of total size */
progress->update_step = progress->content_length * -PS(rfc1867_freq) / 100;
}
progress->next_update = 0;
progress->next_update_time = 0.0;
ALLOC_INIT_ZVAL(progress->data);
array_init(progress->data);
ALLOC_INIT_ZVAL(progress->post_bytes_processed);
ZVAL_LONG(progress->post_bytes_processed, data->post_bytes_processed);
ALLOC_INIT_ZVAL(progress->files);
array_init(progress->files);
add_assoc_long_ex(progress->data, "start_time", sizeof("start_time"), (long)sapi_get_request_time(TSRMLS_C));
add_assoc_long_ex(progress->data, "content_length", sizeof("content_length"), progress->content_length);
add_assoc_zval_ex(progress->data, "bytes_processed", sizeof("bytes_processed"), progress->post_bytes_processed);
add_assoc_bool_ex(progress->data, "done", sizeof("done"), 0);
add_assoc_zval_ex(progress->data, "files", sizeof("files"), progress->files);
php_rinit_session(0 TSRMLS_CC);
PS(id) = estrndup(Z_STRVAL(progress->sid), Z_STRLEN(progress->sid));
PS(apply_trans_sid) = progress->apply_trans_sid;
PS(send_cookie) = 0;
}
ALLOC_INIT_ZVAL(progress->current_file);
array_init(progress->current_file);
ALLOC_INIT_ZVAL(progress->current_file_bytes_processed);
ZVAL_LONG(progress->current_file_bytes_processed, 0);
/* Each uploaded file has its own array. Trying to make it close to $_FILES entries. */
add_assoc_string_ex(progress->current_file, "field_name", sizeof("field_name"), data->name, 1);
add_assoc_string_ex(progress->current_file, "name", sizeof("name"), *data->filename, 1);
add_assoc_null_ex(progress->current_file, "tmp_name", sizeof("tmp_name"));
add_assoc_long_ex(progress->current_file, "error", sizeof("error"), 0);
add_assoc_bool_ex(progress->current_file, "done", sizeof("done"), 0);
add_assoc_long_ex(progress->current_file, "start_time", sizeof("start_time"), (long)time(NULL));
add_assoc_zval_ex(progress->current_file, "bytes_processed", sizeof("bytes_processed"), progress->current_file_bytes_processed);
add_next_index_zval(progress->files, progress->current_file);
Z_LVAL_P(progress->post_bytes_processed) = data->post_bytes_processed;
php_session_rfc1867_update(progress, 0 TSRMLS_CC);
}
break;
case MULTIPART_EVENT_FILE_DATA: {
multipart_event_file_data *data = (multipart_event_file_data *) event_data;
if (!Z_TYPE(progress->sid) || !progress->key.c) {
break;
}
Z_LVAL_P(progress->current_file_bytes_processed) = data->offset + data->length;
Z_LVAL_P(progress->post_bytes_processed) = data->post_bytes_processed;
php_session_rfc1867_update(progress, 0 TSRMLS_CC);
}
break;
case MULTIPART_EVENT_FILE_END: {
multipart_event_file_end *data = (multipart_event_file_end *) event_data;
if (!Z_TYPE(progress->sid) || !progress->key.c) {
break;
}
if (data->temp_filename) {
add_assoc_string_ex(progress->current_file, "tmp_name", sizeof("tmp_name"), data->temp_filename, 1);
}
add_assoc_long_ex(progress->current_file, "error", sizeof("error"), data->cancel_upload);
add_assoc_bool_ex(progress->current_file, "done", sizeof("done"), 1);
Z_LVAL_P(progress->post_bytes_processed) = data->post_bytes_processed;
php_session_rfc1867_update(progress, 0 TSRMLS_CC);
}
break;
case MULTIPART_EVENT_END: {
multipart_event_end *data = (multipart_event_end *) event_data;
if (Z_TYPE(progress->sid) && progress->key.c) {
if (PS(rfc1867_cleanup)) {
php_session_rfc1867_cleanup(progress TSRMLS_CC);
} else {
add_assoc_bool_ex(progress->data, "done", sizeof("done"), 1);
Z_LVAL_P(progress->post_bytes_processed) = data->post_bytes_processed;
php_session_rfc1867_update(progress, 1 TSRMLS_CC);
}
php_rshutdown_session_globals(TSRMLS_C);
}
if (progress->data) {
zval_ptr_dtor(&progress->data);
}
zval_dtor(&progress->sid);
smart_str_free(&progress->key);
efree(progress);
progress = NULL;
PS(rfc1867_progress) = NULL;
}
break;
}
if (progress && progress->cancel_upload) {
return FAILURE;
}
return retval;
} /* }}} */
| 5,708 |
152,652 | 0 |
bool HTMLFormControlElement::isRequired() const {
return fastHasAttribute(requiredAttr);
}
| 5,709 |
115,306 | 0 |
SignatureUtil::~SignatureUtil() {}
| 5,710 |
59,950 | 0 |
static int snd_seq_device_dev_disconnect(struct snd_device *device)
{
struct snd_seq_device *dev = device->device_data;
device_del(&dev->dev);
return 0;
}
| 5,711 |
148,406 | 0 |
int WebContentsImpl::GetOuterDelegateFrameTreeNodeId() {
return node_.outer_contents_frame_tree_node_id();
}
| 5,712 |
100,497 | 0 |
void Cache::adjustSize(bool live, int delta)
{
if (live) {
ASSERT(delta >= 0 || ((int)m_liveSize + delta >= 0));
m_liveSize += delta;
} else {
ASSERT(delta >= 0 || ((int)m_deadSize + delta >= 0));
m_deadSize += delta;
}
}
| 5,713 |
136,987 | 0 |
bool HTMLInputElement::SupportsPlaceholder() const {
return input_type_->SupportsPlaceholder();
}
| 5,714 |
156,079 | 0 |
bool IsGoogleDomainUrl(const GURL& url,
SubdomainPermission subdomain_permission,
PortPermission port_permission) {
return IsValidURL(url, port_permission) &&
IsCanonicalHostGoogleHostname(url.host_piece(), subdomain_permission);
}
| 5,715 |
62,139 | 0 |
static void PNGsLong(png_bytep p,png_int_32 value)
{
*p++=(png_byte) ((value >> 24) & 0xff);
*p++=(png_byte) ((value >> 16) & 0xff);
*p++=(png_byte) ((value >> 8) & 0xff);
*p++=(png_byte) (value & 0xff);
}
| 5,716 |
103,661 | 0 |
BrowserRenderProcessHost::BrowserRenderProcessHost(Profile* profile)
: RenderProcessHost(profile),
visible_widgets_(0),
backgrounded_(true),
ALLOW_THIS_IN_INITIALIZER_LIST(cached_dibs_cleaner_(
base::TimeDelta::FromSeconds(5),
this, &BrowserRenderProcessHost::ClearTransportDIBCache)),
accessibility_enabled_(false),
is_initialized_(false) {
widget_helper_ = new RenderWidgetHelper();
ChildProcessSecurityPolicy::GetInstance()->Add(id());
ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
id(), profile->GetPath().Append(
fileapi::SandboxMountPointProvider::kNewFileSystemDirectory),
base::PLATFORM_FILE_OPEN |
base::PLATFORM_FILE_CREATE |
base::PLATFORM_FILE_OPEN_ALWAYS |
base::PLATFORM_FILE_CREATE_ALWAYS |
base::PLATFORM_FILE_OPEN_TRUNCATED |
base::PLATFORM_FILE_READ |
base::PLATFORM_FILE_WRITE |
base::PLATFORM_FILE_EXCLUSIVE_READ |
base::PLATFORM_FILE_EXCLUSIVE_WRITE |
base::PLATFORM_FILE_ASYNC |
base::PLATFORM_FILE_WRITE_ATTRIBUTES |
base::PLATFORM_FILE_ENUMERATE);
ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
id(), profile->GetPath().Append(
fileapi::SandboxMountPointProvider::kOldFileSystemDirectory),
base::PLATFORM_FILE_READ | base::PLATFORM_FILE_WRITE |
base::PLATFORM_FILE_WRITE_ATTRIBUTES | base::PLATFORM_FILE_ENUMERATE);
ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
id(), profile->GetPath().Append(
fileapi::SandboxMountPointProvider::kRenamedOldFileSystemDirectory),
base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_CREATE_ALWAYS |
base::PLATFORM_FILE_WRITE);
}
| 5,717 |
185,794 | 1 |
bool AXNodeObject::isModal() const {
if (roleValue() != DialogRole && roleValue() != AlertDialogRole)
return false;
if (hasAttribute(aria_modalAttr)) {
const AtomicString& modal = getAttribute(aria_modalAttr);
if (equalIgnoringCase(modal, "true"))
return true;
if (equalIgnoringCase(modal, "false"))
return false;
}
if (getNode() && isHTMLDialogElement(*getNode()))
return toElement(getNode())->isInTopLayer();
return false;
}
| 5,718 |
41,422 | 0 |
static int xen_hvm_config(struct kvm_vcpu *vcpu, u64 data)
{
struct kvm *kvm = vcpu->kvm;
int lm = is_long_mode(vcpu);
u8 *blob_addr = lm ? (u8 *)(long)kvm->arch.xen_hvm_config.blob_addr_64
: (u8 *)(long)kvm->arch.xen_hvm_config.blob_addr_32;
u8 blob_size = lm ? kvm->arch.xen_hvm_config.blob_size_64
: kvm->arch.xen_hvm_config.blob_size_32;
u32 page_num = data & ~PAGE_MASK;
u64 page_addr = data & PAGE_MASK;
u8 *page;
int r;
r = -E2BIG;
if (page_num >= blob_size)
goto out;
r = -ENOMEM;
page = kzalloc(PAGE_SIZE, GFP_KERNEL);
if (!page)
goto out;
r = -EFAULT;
if (copy_from_user(page, blob_addr + (page_num * PAGE_SIZE), PAGE_SIZE))
goto out_free;
if (kvm_write_guest(kvm, page_addr, page, PAGE_SIZE))
goto out_free;
r = 0;
out_free:
kfree(page);
out:
return r;
}
| 5,719 |
43,076 | 0 |
static void vhost_scsi_ctl_handle_kick(struct vhost_work *work)
{
pr_debug("%s: The handling func for control queue.\n", __func__);
}
| 5,720 |
27,830 | 0 |
static void br_multicast_router_expired(unsigned long data)
{
struct net_bridge_port *port = (void *)data;
struct net_bridge *br = port->br;
spin_lock(&br->multicast_lock);
if (port->multicast_router != 1 ||
timer_pending(&port->multicast_router_timer) ||
hlist_unhashed(&port->rlist))
goto out;
hlist_del_init_rcu(&port->rlist);
out:
spin_unlock(&br->multicast_lock);
}
| 5,721 |
121,088 | 0 |
void BaseMultipleFieldsDateAndTimeInputType::disabledAttributeChanged()
{
m_spinButtonElement->releaseCapture();
m_clearButton->releaseCapture();
if (m_dateTimeEditElement)
m_dateTimeEditElement->disabledStateChanged();
}
| 5,722 |
84,613 | 0 |
check_table_width(struct table *t, double *newwidth, MAT * minv, int itr)
{
int i, j, k, m, bcol, ecol;
int corr = 0;
struct table_cell *cell = &t->cell;
#ifdef __GNUC__
short orgwidth[t->maxcol + 1], corwidth[t->maxcol + 1];
short cwidth[cell->maxcell + 1];
double swidth[cell->maxcell + 1];
#else /* __GNUC__ */
short orgwidth[MAXCOL], corwidth[MAXCOL];
short cwidth[MAXCELL];
double swidth[MAXCELL];
#endif /* __GNUC__ */
double twidth, sxy, *Sxx, stotal;
twidth = 0.;
stotal = 0.;
for (i = 0; i <= t->maxcol; i++) {
twidth += newwidth[i];
stotal += m_entry(minv, i, i);
for (m = 0; m < i; m++) {
stotal += 2 * m_entry(minv, i, m);
}
}
Sxx = NewAtom_N(double, cell->maxcell + 1);
for (k = 0; k <= cell->maxcell; k++) {
j = cell->index[k];
bcol = cell->col[j];
ecol = bcol + cell->colspan[j];
swidth[j] = 0.;
for (i = bcol; i < ecol; i++)
swidth[j] += newwidth[i];
cwidth[j] = cell->width[j] - (cell->colspan[j] - 1) * t->cellspacing;
Sxx[j] = 0.;
for (i = bcol; i < ecol; i++) {
Sxx[j] += m_entry(minv, i, i);
for (m = bcol; m <= ecol; m++) {
if (m < i)
Sxx[j] += 2 * m_entry(minv, i, m);
}
}
}
/* compress table */
corr = check_compressible_cell(t, minv, newwidth, swidth,
cwidth, twidth, Sxx, -1, -1, stotal, corr);
if (itr < MAX_ITERATION && corr > 0)
return corr;
/* compress multicolumn cell */
for (k = cell->maxcell; k >= 0; k--) {
j = cell->index[k];
corr = check_compressible_cell(t, minv, newwidth, swidth,
cwidth, twidth, Sxx,
-1, j, Sxx[j], corr);
if (itr < MAX_ITERATION && corr > 0)
return corr;
}
/* compress single column cell */
for (i = 0; i <= t->maxcol; i++) {
corr = check_compressible_cell(t, minv, newwidth, swidth,
cwidth, twidth, Sxx,
i, -1, m_entry(minv, i, i), corr);
if (itr < MAX_ITERATION && corr > 0)
return corr;
}
for (i = 0; i <= t->maxcol; i++)
corwidth[i] = orgwidth[i] = round(newwidth[i]);
check_minimum_width(t, corwidth);
for (i = 0; i <= t->maxcol; i++) {
double sx = sqrt(m_entry(minv, i, i));
if (sx < 0.1)
continue;
if (orgwidth[i] < t->minimum_width[i] &&
corwidth[i] == t->minimum_width[i]) {
double w = (sx > 0.5) ? 0.5 : sx * 0.2;
sxy = 0.;
for (m = 0; m <= t->maxcol; m++) {
if (m == i)
continue;
sxy += m_entry(minv, i, m);
}
if (sxy <= 0.) {
correct_table_matrix(t, i, 1, t->minimum_width[i], w);
corr++;
}
}
}
for (k = 0; k <= cell->maxcell; k++) {
int nwidth = 0, mwidth;
double sx;
j = cell->index[k];
sx = sqrt(Sxx[j]);
if (sx < 0.1)
continue;
bcol = cell->col[j];
ecol = bcol + cell->colspan[j];
for (i = bcol; i < ecol; i++)
nwidth += corwidth[i];
mwidth =
cell->minimum_width[j] - (cell->colspan[j] - 1) * t->cellspacing;
if (mwidth > swidth[j] && mwidth == nwidth) {
double w = (sx > 0.5) ? 0.5 : sx * 0.2;
sxy = 0.;
for (i = bcol; i < ecol; i++) {
for (m = 0; m <= t->maxcol; m++) {
if (m >= bcol && m < ecol)
continue;
sxy += m_entry(minv, i, m);
}
}
if (sxy <= 0.) {
correct_table_matrix(t, bcol, cell->colspan[j], mwidth, w);
corr++;
}
}
}
if (itr >= MAX_ITERATION)
return 0;
else
return corr;
}
| 5,723 |
174,131 | 0 |
OMX::OMX()
: mMaster(new OMXMaster),
mNodeCounter(0) {
}
| 5,724 |
135,927 | 0 |
void ContainerNode::checkForChildrenAdjacentRuleChanges()
{
bool hasDirectAdjacentRules = childrenAffectedByDirectAdjacentRules();
bool hasIndirectAdjacentRules = childrenAffectedByIndirectAdjacentRules();
if (!hasDirectAdjacentRules && !hasIndirectAdjacentRules)
return;
unsigned forceCheckOfNextElementCount = 0;
bool forceCheckOfAnyElementSibling = false;
Document& document = this->document();
for (Element* child = ElementTraversal::firstChild(*this); child; child = ElementTraversal::nextSibling(*child)) {
bool childRulesChanged = child->needsStyleRecalc() && child->styleChangeType() >= SubtreeStyleChange;
if (forceCheckOfNextElementCount || forceCheckOfAnyElementSibling)
child->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::SiblingSelector));
if (childRulesChanged && hasDirectAdjacentRules)
forceCheckOfNextElementCount = document.styleEngine().maxDirectAdjacentSelectors();
else if (forceCheckOfNextElementCount)
--forceCheckOfNextElementCount;
forceCheckOfAnyElementSibling = forceCheckOfAnyElementSibling || (childRulesChanged && hasIndirectAdjacentRules);
}
}
| 5,725 |
59,298 | 0 |
static inline void posix_cpu_timers_init_group(struct signal_struct *sig) { }
| 5,726 |
47,082 | 0 |
static int __init init(void)
{
if (!force && is_blacklisted_cpu()) {
printk(KERN_INFO
"twofish-x86_64-3way: performance on this CPU "
"would be suboptimal: disabling "
"twofish-x86_64-3way.\n");
return -ENODEV;
}
return crypto_register_algs(tf_algs, ARRAY_SIZE(tf_algs));
}
| 5,727 |
159,813 | 0 |
void XSSAuditor::InitForFragment() {
DCHECK(IsMainThread());
DCHECK_EQ(state_, kUninitialized);
state_ = kFilteringTokens;
DCHECK(!is_enabled_);
}
| 5,728 |
8,101 | 0 |
GBool GfxResources::lookupMarkedContentNF(char *name, Object *obj) {
GfxResources *resPtr;
for (resPtr = this; resPtr; resPtr = resPtr->next) {
if (resPtr->propertiesDict.isDict()) {
if (!resPtr->propertiesDict.dictLookupNF(name, obj)->isNull())
return gTrue;
obj->free();
}
}
error(-1, "Marked Content '%s' is unknown", name);
return gFalse;
}
| 5,729 |
171,848 | 0 |
void btif_hl_display_calling_process_name(void)
{
char name[16];
prctl(BTIF_IF_GET_NAME, name, 0, 0, 0);
BTIF_TRACE_DEBUG("Process name (%s)", name);
}
| 5,730 |
186,614 | 1 |
base::string16 GetApplicationNameForProtocol(const GURL& url) {
base::string16 application_name;
// Windows 8 or above has a new protocol association query.
if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
application_name = GetAppForProtocolUsingAssocQuery(url);
if (!application_name.empty())
return application_name;
}
return GetAppForProtocolUsingRegistry(url);
}
| 5,731 |
73,480 | 0 |
MagickExport CacheType GetPixelCacheType(const Image *image)
{
return(GetImagePixelCacheType(image));
}
| 5,732 |
42,851 | 0 |
static void on_sensitive_ticket_clicked_cb(GtkWidget *button, gpointer user_data)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)))
{
xsetenv(CREATE_PRIVATE_TICKET, "1");
}
else
{
safe_unsetenv(CREATE_PRIVATE_TICKET);
}
}
| 5,733 |
2,554 | 0 |
report_parse_error(JsonParseContext ctx, JsonLexContext *lex)
{
char *token;
int toklen;
/* Handle case where the input ended prematurely. */
if (lex->token_start == NULL || lex->token_type == JSON_TOKEN_END)
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type json"),
errdetail("The input string ended unexpectedly."),
report_json_context(lex)));
/* Separate out the current token. */
toklen = lex->token_terminator - lex->token_start;
token = palloc(toklen + 1);
memcpy(token, lex->token_start, toklen);
token[toklen] = '\0';
/* Complain, with the appropriate detail message. */
if (ctx == JSON_PARSE_END)
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type json"),
errdetail("Expected end of input, but found \"%s\".",
token),
report_json_context(lex)));
else
{
switch (ctx)
{
case JSON_PARSE_VALUE:
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type json"),
errdetail("Expected JSON value, but found \"%s\".",
token),
report_json_context(lex)));
break;
case JSON_PARSE_STRING:
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type json"),
errdetail("Expected string, but found \"%s\".",
token),
report_json_context(lex)));
break;
case JSON_PARSE_ARRAY_START:
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type json"),
errdetail("Expected array element or \"]\", but found \"%s\".",
token),
report_json_context(lex)));
break;
case JSON_PARSE_ARRAY_NEXT:
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type json"),
errdetail("Expected \",\" or \"]\", but found \"%s\".",
token),
report_json_context(lex)));
break;
case JSON_PARSE_OBJECT_START:
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type json"),
errdetail("Expected string or \"}\", but found \"%s\".",
token),
report_json_context(lex)));
break;
case JSON_PARSE_OBJECT_LABEL:
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type json"),
errdetail("Expected \":\", but found \"%s\".",
token),
report_json_context(lex)));
break;
case JSON_PARSE_OBJECT_NEXT:
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type json"),
errdetail("Expected \",\" or \"}\", but found \"%s\".",
token),
report_json_context(lex)));
break;
case JSON_PARSE_OBJECT_COMMA:
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type json"),
errdetail("Expected string, but found \"%s\".",
token),
report_json_context(lex)));
break;
default:
elog(ERROR, "unexpected json parse state: %d", ctx);
}
| 5,734 |
166,787 | 0 |
void NormalPageArena::VerifyMarking() {
#if DCHECK_IS_ON()
SetAllocationPoint(nullptr, 0);
for (NormalPage* page = static_cast<NormalPage*>(first_page_); page;
page = static_cast<NormalPage*>(page->Next()))
page->VerifyMarking();
#endif // DCHECK_IS_ON()
}
| 5,735 |
112,060 | 0 |
void VerifyTestBookmarkDataInEntry(Entry* entry) {
const sync_pb::EntitySpecifics& specifics = entry->Get(syncable::SPECIFICS);
EXPECT_TRUE(specifics.has_bookmark());
EXPECT_EQ("PNG", specifics.bookmark().favicon());
EXPECT_EQ("http://demo/", specifics.bookmark().url());
}
| 5,736 |
135,971 | 0 |
void ContainerNode::setFocus(bool received)
{
if (ShadowRoot* root = containingShadowRoot()) {
if (root->type() != ShadowRootType::UserAgent)
shadowHost()->setFocus(received);
}
if (isElementNode() && document().focusedElement() && document().focusedElement() != this) {
if (toElement(this)->authorShadowRoot())
received = received && toElement(this)->authorShadowRoot()->delegatesFocus();
}
if (focused() == received)
return;
Node::setFocus(received);
focusStateChanged();
if (layoutObject() || received)
return;
if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByFocus() && styleChangeType() < SubtreeStyleChange)
document().styleEngine().pseudoStateChangedForElement(CSSSelector::PseudoFocus, *toElement(this));
else
setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::createWithExtraData(StyleChangeReason::PseudoClass, StyleChangeExtraData::Focus));
}
| 5,737 |
1,234 | 0 |
SplashError Splash::clipToRect(SplashCoord x0, SplashCoord y0,
SplashCoord x1, SplashCoord y1) {
return state->clip->clipToRect(x0, y0, x1, y1);
}
| 5,738 |
184,772 | 1 |
static v8::Handle<v8::Value> convert4Callback(const v8::Arguments& args)
{
INC_STATS("DOM.TestObj.convert4");
if (args.Length() < 1)
return V8Proxy::throwNotEnoughArgumentsError();
TestObj* imp = V8TestObj::toNative(args.Holder());
EXCEPTION_BLOCK(d*, , V8d::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8d::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
imp->convert4();
return v8::Handle<v8::Value>();
}
| 5,739 |
60,705 | 0 |
int sctp_transport_walk_start(struct rhashtable_iter *iter)
{
int err;
rhltable_walk_enter(&sctp_transport_hashtable, iter);
err = rhashtable_walk_start(iter);
if (err && err != -EAGAIN) {
rhashtable_walk_stop(iter);
rhashtable_walk_exit(iter);
return err;
}
return 0;
}
| 5,740 |
7,930 | 0 |
static void emitnumber(JF, double num)
{
if (num == 0) {
emit(J, F, OP_NUMBER_0);
if (signbit(num))
emit(J, F, OP_NEG);
} else if (num == 1) {
emit(J, F, OP_NUMBER_1);
} else if (num == (js_Instruction)num) {
emit(J, F, OP_NUMBER_POS);
emitraw(J, F, (js_Instruction)num);
} else if (num < 0 && -num == (js_Instruction)(-num)) {
emit(J, F, OP_NUMBER_NEG);
emitraw(J, F, (js_Instruction)(-num));
} else {
emit(J, F, OP_NUMBER);
emitraw(J, F, addnumber(J, F, num));
}
}
| 5,741 |
30,695 | 0 |
static void __sco_sock_close(struct sock *sk)
{
BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
switch (sk->sk_state) {
case BT_LISTEN:
sco_sock_cleanup_listen(sk);
break;
case BT_CONNECTED:
case BT_CONFIG:
if (sco_pi(sk)->conn->hcon) {
sk->sk_state = BT_DISCONN;
sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
hci_conn_put(sco_pi(sk)->conn->hcon);
sco_pi(sk)->conn->hcon = NULL;
} else
sco_chan_del(sk, ECONNRESET);
break;
case BT_CONNECT2:
case BT_CONNECT:
case BT_DISCONN:
sco_chan_del(sk, ECONNRESET);
break;
default:
sock_set_flag(sk, SOCK_ZAPPED);
break;
}
}
| 5,742 |
23,558 | 0 |
void dm_linear_exit(void)
{
dm_unregister_target(&linear_target);
}
| 5,743 |
42,627 | 0 |
static int udp_v6_send_skb(struct sk_buff *skb, struct flowi6 *fl6)
{
struct sock *sk = skb->sk;
struct udphdr *uh;
int err = 0;
int is_udplite = IS_UDPLITE(sk);
__wsum csum = 0;
int offset = skb_transport_offset(skb);
int len = skb->len - offset;
/*
* Create a UDP header
*/
uh = udp_hdr(skb);
uh->source = fl6->fl6_sport;
uh->dest = fl6->fl6_dport;
uh->len = htons(len);
uh->check = 0;
if (is_udplite)
csum = udplite_csum(skb);
else if (udp_sk(sk)->no_check6_tx) { /* UDP csum disabled */
skb->ip_summed = CHECKSUM_NONE;
goto send;
} else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
udp6_hwcsum_outgoing(sk, skb, &fl6->saddr, &fl6->daddr, len);
goto send;
} else
csum = udp_csum(skb);
/* add protocol-dependent pseudo-header */
uh->check = csum_ipv6_magic(&fl6->saddr, &fl6->daddr,
len, fl6->flowi6_proto, csum);
if (uh->check == 0)
uh->check = CSUM_MANGLED_0;
send:
err = ip6_send_skb(skb);
if (err) {
if (err == -ENOBUFS && !inet6_sk(sk)->recverr) {
UDP6_INC_STATS_USER(sock_net(sk),
UDP_MIB_SNDBUFERRORS, is_udplite);
err = 0;
}
} else
UDP6_INC_STATS_USER(sock_net(sk),
UDP_MIB_OUTDATAGRAMS, is_udplite);
return err;
}
| 5,744 |
141,761 | 0 |
void V8InjectedScriptHost::bindCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
if (info.Length() < 2 || !info[1]->IsString())
return;
InjectedScriptNative* injectedScriptNative = InjectedScriptNative::fromInjectedScriptHost(info.Holder());
if (!injectedScriptNative)
return;
v8::Local<v8::String> v8groupName = info[1]->ToString(info.GetIsolate());
String16 groupName = toProtocolStringWithTypeCheck(v8groupName);
int id = injectedScriptNative->bind(info[0], groupName);
info.GetReturnValue().Set(id);
}
| 5,745 |
132,876 | 0 |
PictureLayerImplTestWithDelegatingRenderer() : PictureLayerImplTest() {}
| 5,746 |
128,449 | 0 |
bool RenderLayerScrollableArea::shouldPlaceVerticalScrollbarOnLeft() const
{
return box().style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft();
}
| 5,747 |
117,991 | 0 |
static void handleFatalErrorInV8()
{
CRASH();
}
| 5,748 |
59,223 | 0 |
_kdc_is_anon_request(const KDC_REQ_BODY *b)
{
/* some versions of heimdal use bit 14 instead of 16 for
request_anonymous, as indicated in the anonymous draft prior to
version 11. Bit 14 is assigned to S4U2Proxy, but all S4U2Proxy
requests will have a second ticket; don't consider those anonymous */
return (b->kdc_options.request_anonymous ||
(b->kdc_options.constrained_delegation && !b->additional_tickets));
}
| 5,749 |
111,262 | 0 |
void WebPagePrivate::onInputLocaleChanged(bool isRTL)
{
if (isRTL != m_webSettings->isWritingDirectionRTL()) {
m_webSettings->setWritingDirectionRTL(isRTL);
m_inputHandler->handleInputLocaleChanged(isRTL);
}
}
| 5,750 |
42,867 | 0 |
static void save_to_event_log(struct analyze_event_data *evd, const char *str)
{
static const char delim[] = {
[LOGSTATE_FIRSTLINE] = '>',
[LOGSTATE_BEGLINE] = ' ',
[LOGSTATE_ERRLINE] = '*',
};
while (str[0])
{
char *end = strchrnul(str, '\n');
char end_char = *end;
if (end_char == '\n')
end++;
switch (evd->event_log_state)
{
case LOGSTATE_FIRSTLINE:
case LOGSTATE_BEGLINE:
case LOGSTATE_ERRLINE:
/* skip empty lines */
if (str[0] == '\n')
goto next;
strbuf_append_strf(evd->event_log, "%s%c %.*s",
iso_date_string(NULL),
delim[evd->event_log_state],
(int)(end - str), str
);
break;
case LOGSTATE_MIDLINE:
strbuf_append_strf(evd->event_log, "%.*s", (int)(end - str), str);
break;
}
evd->event_log_state = LOGSTATE_MIDLINE;
if (end_char != '\n')
break;
evd->event_log_state = LOGSTATE_BEGLINE;
next:
str = end;
}
}
| 5,751 |
34,226 | 0 |
ip_vs_service_get(struct net *net, int af, __u32 fwmark, __u16 protocol,
const union nf_inet_addr *vaddr, __be16 vport)
{
struct ip_vs_service *svc;
struct netns_ipvs *ipvs = net_ipvs(net);
read_lock(&__ip_vs_svc_lock);
/*
* Check the table hashed by fwmark first
*/
if (fwmark) {
svc = __ip_vs_svc_fwm_find(net, af, fwmark);
if (svc)
goto out;
}
/*
* Check the table hashed by <protocol,addr,port>
* for "full" addressed entries
*/
svc = __ip_vs_service_find(net, af, protocol, vaddr, vport);
if (svc == NULL
&& protocol == IPPROTO_TCP
&& atomic_read(&ipvs->ftpsvc_counter)
&& (vport == FTPDATA || ntohs(vport) >= PROT_SOCK)) {
/*
* Check if ftp service entry exists, the packet
* might belong to FTP data connections.
*/
svc = __ip_vs_service_find(net, af, protocol, vaddr, FTPPORT);
}
if (svc == NULL
&& atomic_read(&ipvs->nullsvc_counter)) {
/*
* Check if the catch-all port (port zero) exists
*/
svc = __ip_vs_service_find(net, af, protocol, vaddr, 0);
}
out:
if (svc)
atomic_inc(&svc->usecnt);
read_unlock(&__ip_vs_svc_lock);
IP_VS_DBG_BUF(9, "lookup service: fwm %u %s %s:%u %s\n",
fwmark, ip_vs_proto_name(protocol),
IP_VS_DBG_ADDR(af, vaddr), ntohs(vport),
svc ? "hit" : "not hit");
return svc;
}
| 5,752 |
119,492 | 0 |
bool ScriptController::shouldBypassMainWorldContentSecurityPolicy()
{
if (DOMWrapperWorld* world = isolatedWorldForEnteredContext())
return world->isolatedWorldHasContentSecurityPolicy();
return false;
}
| 5,753 |
159,808 | 0 |
bool XSSAuditor::FilterScriptToken(const FilterTokenRequest& request) {
DCHECK_EQ(request.token.GetType(), HTMLToken::kStartTag);
DCHECK(HasName(request.token, scriptTag));
bool did_block_script = false;
script_tag_found_in_request_ =
IsContainedInRequest(CanonicalizedSnippetForTagName(request));
if (script_tag_found_in_request_) {
did_block_script |= EraseAttributeIfInjected(
request, srcAttr, BlankURL().GetString(), kSrcLikeAttributeTruncation);
did_block_script |= EraseAttributeIfInjected(request, SVGNames::hrefAttr,
BlankURL().GetString(),
kSrcLikeAttributeTruncation);
did_block_script |= EraseAttributeIfInjected(request, XLinkNames::hrefAttr,
BlankURL().GetString(),
kSrcLikeAttributeTruncation);
}
return did_block_script;
}
| 5,754 |
25,397 | 0 |
asmlinkage void do_mdmx(struct pt_regs *regs)
{
force_sig(SIGILL, current);
}
| 5,755 |
81,778 | 0 |
static inline void restore_ac_coeffs(MpegEncContext *s, int16_t block[6][64],
const int dir[6], uint8_t *st[6],
const int zigzag_last_index[6])
{
int i, n;
memcpy(s->block_last_index, zigzag_last_index, sizeof(int) * 6);
for (n = 0; n < 6; n++) {
int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
st[n] = s->intra_scantable.permutated;
if (dir[n]) {
/* top prediction */
for (i = 1; i < 8; i++)
block[n][s->idsp.idct_permutation[i]] = ac_val[i + 8];
} else {
/* left prediction */
for (i = 1; i < 8; i++)
block[n][s->idsp.idct_permutation[i << 3]] = ac_val[i];
}
}
}
| 5,756 |
175,068 | 0 |
void SoundChannel::callback(int event, void* user, void *info)
{
SoundChannel* channel = static_cast<SoundChannel*>((void *)((unsigned long)user & ~1));
channel->process(event, info, (unsigned long)user & 1);
}
| 5,757 |
73,743 | 0 |
static size_t EncodeImage(Image *image,const size_t bytes_per_line,
const unsigned char *pixels,unsigned char *compressed_pixels)
{
MagickBooleanType
status;
register const unsigned char
*p;
register ssize_t
i,
x;
register unsigned char
*q;
ssize_t
y;
/*
Runlength encode pixels.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(pixels != (const unsigned char *) NULL);
assert(compressed_pixels != (unsigned char *) NULL);
p=pixels;
q=compressed_pixels;
i=0;
for (y=0; y < (ssize_t) image->rows; y++)
{
for (x=0; x < (ssize_t) bytes_per_line; x+=i)
{
/*
Determine runlength.
*/
for (i=1; ((x+i) < (ssize_t) bytes_per_line); i++)
if ((i == 255) || (*(p+i) != *p))
break;
*q++=(unsigned char) i;
*q++=(*p);
p+=i;
}
/*
End of line.
*/
*q++=(unsigned char) 0x00;
*q++=(unsigned char) 0x00;
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
image->rows);
if (status == MagickFalse)
break;
}
/*
End of bitmap.
*/
*q++=(unsigned char) 0x00;
*q++=(unsigned char) 0x01;
return((size_t) (q-compressed_pixels));
}
| 5,758 |
66,258 | 0 |
vbf_stp_fail(struct worker *wrk, const struct busyobj *bo)
{
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(bo->fetch_objcore, OBJCORE_MAGIC);
assert(bo->fetch_objcore->boc->state < BOS_FINISHED);
HSH_Fail(bo->fetch_objcore);
if (!(bo->fetch_objcore->flags & OC_F_BUSY))
HSH_Kill(bo->fetch_objcore);
ObjSetState(wrk, bo->fetch_objcore, BOS_FAILED);
return (F_STP_DONE);
}
| 5,759 |
14,987 | 0 |
ProcInstallColormap(ClientPtr client)
{
ColormapPtr pcmp;
int rc;
REQUEST(xResourceReq);
REQUEST_SIZE_MATCH(xResourceReq);
rc = dixLookupResourceByType((void **) &pcmp, stuff->id, RT_COLORMAP,
client, DixInstallAccess);
if (rc != Success)
goto out;
rc = XaceHook(XACE_SCREEN_ACCESS, client, pcmp->pScreen, DixSetAttrAccess);
if (rc != Success) {
if (rc == BadValue)
rc = BadColor;
goto out;
}
(*(pcmp->pScreen->InstallColormap)) (pcmp);
return Success;
out:
client->errorValue = stuff->id;
return rc;
}
| 5,760 |
45,684 | 0 |
static void crypto_ctr_exit_tfm(struct crypto_tfm *tfm)
{
struct crypto_ctr_ctx *ctx = crypto_tfm_ctx(tfm);
crypto_free_cipher(ctx->child);
}
| 5,761 |
175,537 | 0 |
void encodeBase64(
const void *_data, size_t size, AString *out) {
out->clear();
const uint8_t *data = (const uint8_t *)_data;
size_t i;
for (i = 0; i < (size / 3) * 3; i += 3) {
uint8_t x1 = data[i];
uint8_t x2 = data[i + 1];
uint8_t x3 = data[i + 2];
out->append(encode6Bit(x1 >> 2));
out->append(encode6Bit((x1 << 4 | x2 >> 4) & 0x3f));
out->append(encode6Bit((x2 << 2 | x3 >> 6) & 0x3f));
out->append(encode6Bit(x3 & 0x3f));
}
switch (size % 3) {
case 0:
break;
case 2:
{
uint8_t x1 = data[i];
uint8_t x2 = data[i + 1];
out->append(encode6Bit(x1 >> 2));
out->append(encode6Bit((x1 << 4 | x2 >> 4) & 0x3f));
out->append(encode6Bit((x2 << 2) & 0x3f));
out->append('=');
break;
}
default:
{
uint8_t x1 = data[i];
out->append(encode6Bit(x1 >> 2));
out->append(encode6Bit((x1 << 4) & 0x3f));
out->append("==");
break;
}
}
}
| 5,762 |
5,827 | 0 |
static void ehci_trace_guest_bug(EHCIState *s, const char *message)
{
trace_usb_ehci_guest_bug(message);
fprintf(stderr, "ehci warning: %s\n", message);
}
| 5,763 |
140,072 | 0 |
void HTMLMediaElement::requestRemotePlaybackControl() {
if (webMediaPlayer())
webMediaPlayer()->requestRemotePlaybackControl();
}
| 5,764 |
139,721 | 0 |
WebURLRequest::RequestContext ResourceFetcher::DetermineRequestContext(
Resource::Type type) const {
return DetermineRequestContext(type, Context().IsMainFrame());
}
| 5,765 |
52,629 | 0 |
ppp_get_stats(struct ppp *ppp, struct ppp_stats *st)
{
struct slcompress *vj = ppp->vj;
memset(st, 0, sizeof(*st));
st->p.ppp_ipackets = ppp->stats64.rx_packets;
st->p.ppp_ierrors = ppp->dev->stats.rx_errors;
st->p.ppp_ibytes = ppp->stats64.rx_bytes;
st->p.ppp_opackets = ppp->stats64.tx_packets;
st->p.ppp_oerrors = ppp->dev->stats.tx_errors;
st->p.ppp_obytes = ppp->stats64.tx_bytes;
if (!vj)
return;
st->vj.vjs_packets = vj->sls_o_compressed + vj->sls_o_uncompressed;
st->vj.vjs_compressed = vj->sls_o_compressed;
st->vj.vjs_searches = vj->sls_o_searches;
st->vj.vjs_misses = vj->sls_o_misses;
st->vj.vjs_errorin = vj->sls_i_error;
st->vj.vjs_tossed = vj->sls_i_tossed;
st->vj.vjs_uncompressedin = vj->sls_i_uncompressed;
st->vj.vjs_compressedin = vj->sls_i_compressed;
}
| 5,766 |
177,183 | 0 |
DeathNotifier(const sp<AMessage> ¬ify)
: mNotify(notify) {
}
| 5,767 |
6,091 | 0 |
e1000e_txdesc_writeback(E1000ECore *core, dma_addr_t base,
struct e1000_tx_desc *dp, bool *ide, int queue_idx)
{
uint32_t txd_upper, txd_lower = le32_to_cpu(dp->lower.data);
if (!(txd_lower & E1000_TXD_CMD_RS) &&
!(core->mac[IVAR] & E1000_IVAR_TX_INT_EVERY_WB)) {
return 0;
}
*ide = (txd_lower & E1000_TXD_CMD_IDE) ? true : false;
txd_upper = le32_to_cpu(dp->upper.data) | E1000_TXD_STAT_DD;
dp->upper.data = cpu_to_le32(txd_upper);
pci_dma_write(core->owner, base + ((char *)&dp->upper - (char *)dp),
&dp->upper, sizeof(dp->upper));
return e1000e_tx_wb_interrupt_cause(core, queue_idx);
}
| 5,768 |
9,987 | 0 |
adisplay_done( ADisplay display )
{
grDoneBitmap( display->bitmap );
grDoneSurface( display->surface );
display->bitmap = NULL;
display->surface = NULL;
grDoneDevices();
}
| 5,769 |
77,881 | 0 |
test_bson_append_double (void)
{
bson_t *b;
bson_t *b2;
b = bson_new ();
BSON_ASSERT (bson_append_double (b, "double", -1, 123.4567));
b2 = get_bson ("test20.bson");
BSON_ASSERT_BSON_EQUAL (b, b2);
bson_destroy (b);
bson_destroy (b2);
}
| 5,770 |
96,785 | 0 |
static void end_requests(struct fuse_conn *fc, struct list_head *head)
{
while (!list_empty(head)) {
struct fuse_req *req;
req = list_entry(head->next, struct fuse_req, list);
req->out.h.error = -ECONNABORTED;
clear_bit(FR_SENT, &req->flags);
list_del_init(&req->list);
request_end(fc, req);
}
}
| 5,771 |
40,473 | 0 |
static int iucv_fragment_skb(struct sock *sk, struct sk_buff *skb, int len)
{
int dataleft, size, copied = 0;
struct sk_buff *nskb;
dataleft = len;
while (dataleft) {
if (dataleft >= sk->sk_rcvbuf / 4)
size = sk->sk_rcvbuf / 4;
else
size = dataleft;
nskb = alloc_skb(size, GFP_ATOMIC | GFP_DMA);
if (!nskb)
return -ENOMEM;
/* copy target class to control buffer of new skb */
IUCV_SKB_CB(nskb)->class = IUCV_SKB_CB(skb)->class;
/* copy data fragment */
memcpy(nskb->data, skb->data + copied, size);
copied += size;
dataleft -= size;
skb_reset_transport_header(nskb);
skb_reset_network_header(nskb);
nskb->len = size;
skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, nskb);
}
return 0;
}
| 5,772 |
24,362 | 0 |
static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)
{
int may_free = 1;
struct buffer_head *bh = jh2bh(jh);
if (jh->b_cp_transaction) {
JBUFFER_TRACE(jh, "on running+cp transaction");
__jbd2_journal_temp_unlink_buffer(jh);
/*
* We don't want to write the buffer anymore, clear the
* bit so that we don't confuse checks in
* __journal_file_buffer
*/
clear_buffer_dirty(bh);
__jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
may_free = 0;
} else {
JBUFFER_TRACE(jh, "on running transaction");
__jbd2_journal_unfile_buffer(jh);
}
return may_free;
}
| 5,773 |
89,706 | 0 |
static void nfc_llcp_recv_agf(struct nfc_llcp_local *local, struct sk_buff *skb)
{
u8 ptype;
u16 pdu_len;
struct sk_buff *new_skb;
if (skb->len <= LLCP_HEADER_SIZE) {
pr_err("Malformed AGF PDU\n");
return;
}
skb_pull(skb, LLCP_HEADER_SIZE);
while (skb->len > LLCP_AGF_PDU_HEADER_SIZE) {
pdu_len = skb->data[0] << 8 | skb->data[1];
skb_pull(skb, LLCP_AGF_PDU_HEADER_SIZE);
if (pdu_len < LLCP_HEADER_SIZE || pdu_len > skb->len) {
pr_err("Malformed AGF PDU\n");
return;
}
ptype = nfc_llcp_ptype(skb);
if (ptype == LLCP_PDU_SYMM || ptype == LLCP_PDU_AGF)
goto next;
new_skb = nfc_alloc_recv_skb(pdu_len, GFP_KERNEL);
if (new_skb == NULL) {
pr_err("Could not allocate PDU\n");
return;
}
skb_put_data(new_skb, skb->data, pdu_len);
nfc_llcp_rx_skb(local, new_skb);
kfree_skb(new_skb);
next:
skb_pull(skb, pdu_len);
}
}
| 5,774 |
20,805 | 0 |
static int kvm_read_guest_virt_helper(gva_t addr, void *val, unsigned int bytes,
struct kvm_vcpu *vcpu, u32 access,
struct x86_exception *exception)
{
void *data = val;
int r = X86EMUL_CONTINUE;
while (bytes) {
gpa_t gpa = vcpu->arch.walk_mmu->gva_to_gpa(vcpu, addr, access,
exception);
unsigned offset = addr & (PAGE_SIZE-1);
unsigned toread = min(bytes, (unsigned)PAGE_SIZE - offset);
int ret;
if (gpa == UNMAPPED_GVA)
return X86EMUL_PROPAGATE_FAULT;
ret = kvm_read_guest(vcpu->kvm, gpa, data, toread);
if (ret < 0) {
r = X86EMUL_IO_NEEDED;
goto out;
}
bytes -= toread;
data += toread;
addr += toread;
}
out:
return r;
}
| 5,775 |
117,058 | 0 |
void SessionService::CommitPendingCloses() {
for (PendingTabCloseIDs::iterator i = pending_tab_close_ids_.begin();
i != pending_tab_close_ids_.end(); ++i) {
ScheduleCommand(CreateTabClosedCommand(*i));
}
pending_tab_close_ids_.clear();
for (PendingWindowCloseIDs::iterator i = pending_window_close_ids_.begin();
i != pending_window_close_ids_.end(); ++i) {
ScheduleCommand(CreateWindowClosedCommand(*i));
}
pending_window_close_ids_.clear();
}
| 5,776 |
169,795 | 0 |
exsltDateParse (const xmlChar *dateTime)
{
exsltDateValPtr dt;
int ret;
const xmlChar *cur = dateTime;
#define RETURN_TYPE_IF_VALID(t) \
if (IS_TZO_CHAR(*cur)) { \
ret = _exsltDateParseTimeZone(&(dt->value.date), &cur); \
if (ret == 0) { \
if (*cur != 0) \
goto error; \
dt->type = t; \
return dt; \
} \
}
if (dateTime == NULL)
return NULL;
if ((*cur != '-') && (*cur < '0') && (*cur > '9'))
return NULL;
dt = exsltDateCreateDate(EXSLT_UNKNOWN);
if (dt == NULL)
return NULL;
if ((cur[0] == '-') && (cur[1] == '-')) {
/*
* It's an incomplete date (xs:gMonthDay, xs:gMonth or
* xs:gDay)
*/
cur += 2;
/* is it an xs:gDay? */
if (*cur == '-') {
++cur;
ret = _exsltDateParseGDay(&(dt->value.date), &cur);
if (ret != 0)
goto error;
RETURN_TYPE_IF_VALID(XS_GDAY);
goto error;
}
/*
* it should be an xs:gMonthDay or xs:gMonth
*/
ret = _exsltDateParseGMonth(&(dt->value.date), &cur);
if (ret != 0)
goto error;
if (*cur != '-')
goto error;
cur++;
/* is it an xs:gMonth? */
if (*cur == '-') {
cur++;
RETURN_TYPE_IF_VALID(XS_GMONTH);
goto error;
}
/* it should be an xs:gMonthDay */
ret = _exsltDateParseGDay(&(dt->value.date), &cur);
if (ret != 0)
goto error;
RETURN_TYPE_IF_VALID(XS_GMONTHDAY);
goto error;
}
/*
* It's a right-truncated date or an xs:time.
* Try to parse an xs:time then fallback on right-truncated dates.
*/
if ((*cur >= '0') && (*cur <= '9')) {
ret = _exsltDateParseTime(&(dt->value.date), &cur);
if (ret == 0) {
/* it's an xs:time */
RETURN_TYPE_IF_VALID(XS_TIME);
}
}
/* fallback on date parsing */
cur = dateTime;
ret = _exsltDateParseGYear(&(dt->value.date), &cur);
if (ret != 0)
goto error;
/* is it an xs:gYear? */
RETURN_TYPE_IF_VALID(XS_GYEAR);
if (*cur != '-')
goto error;
cur++;
ret = _exsltDateParseGMonth(&(dt->value.date), &cur);
if (ret != 0)
goto error;
/* is it an xs:gYearMonth? */
RETURN_TYPE_IF_VALID(XS_GYEARMONTH);
if (*cur != '-')
goto error;
cur++;
ret = _exsltDateParseGDay(&(dt->value.date), &cur);
if ((ret != 0) || !VALID_DATE((&(dt->value.date))))
goto error;
/* is it an xs:date? */
RETURN_TYPE_IF_VALID(XS_DATE);
if (*cur != 'T')
goto error;
cur++;
/* it should be an xs:dateTime */
ret = _exsltDateParseTime(&(dt->value.date), &cur);
if (ret != 0)
goto error;
ret = _exsltDateParseTimeZone(&(dt->value.date), &cur);
if ((ret != 0) || (*cur != 0) || !VALID_DATETIME((&(dt->value.date))))
goto error;
dt->type = XS_DATETIME;
return dt;
error:
if (dt != NULL)
exsltDateFreeDate(dt);
return NULL;
}
| 5,777 |
16,134 | 0 |
GahpServer::command_async_mode_on()
{
static const char* command = "ASYNC_MODE_ON";
if (m_commands_supported->contains_anycase(command)==FALSE) {
return false;
}
write_line(command);
Gahp_Args result;
read_argv(result);
if ( result.argc == 0 || result.argv[0][0] != 'S' ) {
dprintf(D_ALWAYS,"GAHP command '%s' failed\n",command);
return false;
}
return true;
}
| 5,778 |
94,872 | 0 |
static void __handle_link_change(struct usbnet *dev)
{
if (!test_bit(EVENT_DEV_OPEN, &dev->flags))
return;
if (!netif_carrier_ok(dev->net)) {
/* kill URBs for reading packets to save bus bandwidth */
unlink_urbs(dev, &dev->rxq);
/*
* tx_timeout will unlink URBs for sending packets and
* tx queue is stopped by netcore after link becomes off
*/
} else {
/* submitting URBs for reading packets */
tasklet_schedule(&dev->bh);
}
/* hard_mtu or rx_urb_size may change during link change */
usbnet_update_max_qlen(dev);
clear_bit(EVENT_LINK_CHANGE, &dev->flags);
}
| 5,779 |
127,228 | 0 |
void WorkerProcessLauncher::Core::Send(IPC::Message* message) {
DCHECK(caller_task_runner_->BelongsToCurrentThread());
if (ipc_enabled_) {
launcher_delegate_->Send(message);
} else {
delete message;
}
}
| 5,780 |
28,774 | 0 |
bool kvm_irq_delivery_to_apic_fast(struct kvm *kvm, struct kvm_lapic *src,
struct kvm_lapic_irq *irq, int *r, unsigned long *dest_map)
{
struct kvm_apic_map *map;
unsigned long bitmap = 1;
struct kvm_lapic **dst;
int i;
bool ret = false;
*r = -1;
if (irq->shorthand == APIC_DEST_SELF) {
*r = kvm_apic_set_irq(src->vcpu, irq, dest_map);
return true;
}
if (irq->shorthand)
return false;
rcu_read_lock();
map = rcu_dereference(kvm->arch.apic_map);
if (!map)
goto out;
if (irq->dest_mode == 0) { /* physical mode */
if (irq->delivery_mode == APIC_DM_LOWEST ||
irq->dest_id == 0xff)
goto out;
dst = &map->phys_map[irq->dest_id & 0xff];
} else {
u32 mda = irq->dest_id << (32 - map->ldr_bits);
dst = map->logical_map[apic_cluster_id(map, mda)];
bitmap = apic_logical_id(map, mda);
if (irq->delivery_mode == APIC_DM_LOWEST) {
int l = -1;
for_each_set_bit(i, &bitmap, 16) {
if (!dst[i])
continue;
if (l < 0)
l = i;
else if (kvm_apic_compare_prio(dst[i]->vcpu, dst[l]->vcpu) < 0)
l = i;
}
bitmap = (l >= 0) ? 1 << l : 0;
}
}
for_each_set_bit(i, &bitmap, 16) {
if (!dst[i])
continue;
if (*r < 0)
*r = 0;
*r += kvm_apic_set_irq(dst[i]->vcpu, irq, dest_map);
}
ret = true;
out:
rcu_read_unlock();
return ret;
}
| 5,781 |
48,006 | 0 |
xfs_attr_shortform_compare(const void *a, const void *b)
{
xfs_attr_sf_sort_t *sa, *sb;
sa = (xfs_attr_sf_sort_t *)a;
sb = (xfs_attr_sf_sort_t *)b;
if (sa->hash < sb->hash) {
return -1;
} else if (sa->hash > sb->hash) {
return 1;
} else {
return sa->entno - sb->entno;
}
}
| 5,782 |
43,025 | 0 |
static void bpf_flush_icache(void *start, void *end)
{
mm_segment_t old_fs = get_fs();
set_fs(KERNEL_DS);
smp_wmb();
flush_icache_range((unsigned long)start, (unsigned long)end);
set_fs(old_fs);
}
| 5,783 |
19,296 | 0 |
static struct sock *unix_find_socket_byinode(struct inode *i)
{
struct sock *s;
struct hlist_node *node;
spin_lock(&unix_table_lock);
sk_for_each(s, node,
&unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) {
struct dentry *dentry = unix_sk(s)->path.dentry;
if (dentry && dentry->d_inode == i) {
sock_hold(s);
goto found;
}
}
s = NULL;
found:
spin_unlock(&unix_table_lock);
return s;
}
| 5,784 |
134,089 | 0 |
void InputMethodBase::SetStickyFocusedTextInputClient(TextInputClient* client) {
is_sticky_text_input_client_ = (client != NULL);
SetFocusedTextInputClientInternal(client);
}
| 5,785 |
99,502 | 0 |
static uint32_t NPN_MemFlush(uint32_t size)
{
return 0;
}
| 5,786 |
36,737 | 0 |
spnego_gss_acquire_cred_with_password(OM_uint32 *minor_status,
const gss_name_t desired_name,
const gss_buffer_t password,
OM_uint32 time_req,
const gss_OID_set desired_mechs,
gss_cred_usage_t cred_usage,
gss_cred_id_t *output_cred_handle,
gss_OID_set *actual_mechs,
OM_uint32 *time_rec)
{
OM_uint32 status, tmpmin;
gss_OID_set amechs = GSS_C_NULL_OID_SET;
gss_cred_id_t mcred = NULL;
spnego_gss_cred_id_t spcred = NULL;
dsyslog("Entering spnego_gss_acquire_cred_with_password\n");
if (actual_mechs)
*actual_mechs = NULL;
if (time_rec)
*time_rec = 0;
status = get_available_mechs(minor_status, desired_name,
cred_usage, GSS_C_NO_CRED_STORE,
NULL, &amechs);
if (status != GSS_S_COMPLETE)
goto cleanup;
status = gss_acquire_cred_with_password(minor_status, desired_name,
password, time_req, amechs,
cred_usage, &mcred,
actual_mechs, time_rec);
if (status != GSS_S_COMPLETE)
goto cleanup;
spcred = malloc(sizeof(spnego_gss_cred_id_rec));
if (spcred == NULL) {
*minor_status = ENOMEM;
status = GSS_S_FAILURE;
goto cleanup;
}
spcred->neg_mechs = GSS_C_NULL_OID_SET;
spcred->mcred = mcred;
mcred = GSS_C_NO_CREDENTIAL;
*output_cred_handle = (gss_cred_id_t)spcred;
cleanup:
(void) gss_release_oid_set(&tmpmin, &amechs);
(void) gss_release_cred(&tmpmin, &mcred);
dsyslog("Leaving spnego_gss_acquire_cred_with_password\n");
return (status);
}
| 5,787 |
124,492 | 0 |
void RenderBlock::adjustStartEdgeForWritingModeIncludingColumns(LayoutRect& rect) const
{
ASSERT(hasColumns());
if (!hasColumns() || !style()->isFlippedBlocksWritingMode())
return;
ColumnInfo* colInfo = columnInfo();
LayoutUnit columnLogicalHeight = colInfo->columnHeight();
LayoutUnit expandedLogicalHeight = borderBefore() + paddingBefore() + columnCount(colInfo) * columnLogicalHeight + borderAfter() + paddingAfter() + scrollbarLogicalHeight();
if (isHorizontalWritingMode())
rect.setY(expandedLogicalHeight - rect.maxY());
else
rect.setX(expandedLogicalHeight - rect.maxX());
}
| 5,788 |
144,319 | 0 |
void LoginDisplayHostWebUI::OnPreferencesChanged() {
if (is_showing_login_)
login_display_->OnPreferencesChanged();
}
| 5,789 |
122,522 | 0 |
void InspectorClientImpl::getAllocatedObjects(HashSet<const void*>& set)
{
if (WebDevToolsAgentImpl* agent = devToolsAgent())
agent->getAllocatedObjects(set);
}
| 5,790 |
15,814 | 0 |
static char *mac_strdup_printf(const uint8_t *mac)
{
return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x", mac[0],
mac[1], mac[2], mac[3], mac[4], mac[5]);
}
| 5,791 |
48,320 | 0 |
TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc)
{
static const char module[] = "TIFFAppendToStrip";
TIFFDirectory *td = &tif->tif_dir;
uint64 m;
int64 old_byte_count = -1;
if (td->td_stripoffset[strip] == 0 || tif->tif_curoff == 0) {
assert(td->td_nstrips > 0);
if( td->td_stripbytecount[strip] != 0
&& td->td_stripoffset[strip] != 0
&& td->td_stripbytecount[strip] >= (uint64) cc )
{
/*
* There is already tile data on disk, and the new tile
* data we have will fit in the same space. The only
* aspect of this that is risky is that there could be
* more data to append to this strip before we are done
* depending on how we are getting called.
*/
if (!SeekOK(tif, td->td_stripoffset[strip])) {
TIFFErrorExt(tif->tif_clientdata, module,
"Seek error at scanline %lu",
(unsigned long)tif->tif_row);
return (0);
}
}
else
{
/*
* Seek to end of file, and set that as our location to
* write this strip.
*/
td->td_stripoffset[strip] = TIFFSeekFile(tif, 0, SEEK_END);
tif->tif_flags |= TIFF_DIRTYSTRIP;
}
tif->tif_curoff = td->td_stripoffset[strip];
/*
* We are starting a fresh strip/tile, so set the size to zero.
*/
old_byte_count = td->td_stripbytecount[strip];
td->td_stripbytecount[strip] = 0;
}
m = tif->tif_curoff+cc;
if (!(tif->tif_flags&TIFF_BIGTIFF))
m = (uint32)m;
if ((m<tif->tif_curoff)||(m<(uint64)cc))
{
TIFFErrorExt(tif->tif_clientdata, module, "Maximum TIFF file size exceeded");
return (0);
}
if (!WriteOK(tif, data, cc)) {
TIFFErrorExt(tif->tif_clientdata, module, "Write error at scanline %lu",
(unsigned long) tif->tif_row);
return (0);
}
tif->tif_curoff = m;
td->td_stripbytecount[strip] += cc;
if( (int64) td->td_stripbytecount[strip] != old_byte_count )
tif->tif_flags |= TIFF_DIRTYSTRIP;
return (1);
}
| 5,792 |
16,922 | 0 |
static int decompress_buffer(uint8_t *out_buf, int out_buf_size,
const uint8_t *buf, int buf_size)
{
z_stream strm1, *strm = &strm1;
int ret, out_len;
memset(strm, 0, sizeof(*strm));
strm->next_in = (uint8_t *)buf;
strm->avail_in = buf_size;
strm->next_out = out_buf;
strm->avail_out = out_buf_size;
ret = inflateInit2(strm, -12);
if (ret != Z_OK)
return -1;
ret = inflate(strm, Z_FINISH);
out_len = strm->next_out - out_buf;
if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) ||
out_len != out_buf_size) {
inflateEnd(strm);
return -1;
}
inflateEnd(strm);
return 0;
}
| 5,793 |
106,865 | 0 |
BackgroundBleedAvoidance RenderBox::determineBackgroundBleedAvoidance(GraphicsContext* context) const
{
if (context->paintingDisabled())
return BackgroundBleedNone;
const RenderStyle* style = this->style();
if (!style->hasBackground() || !style->hasBorder() || !style->hasBorderRadius() || borderImageIsLoadedAndCanBeRendered())
return BackgroundBleedNone;
AffineTransform ctm = context->getCTM();
FloatSize contextScaling(static_cast<float>(ctm.xScale()), static_cast<float>(ctm.yScale()));
if (borderObscuresBackgroundEdge(contextScaling))
return BackgroundBleedShrinkBackground;
return BackgroundBleedUseTransparencyLayer;
}
| 5,794 |
2,745 | 0 |
_dbus_header_free (DBusHeader *header)
{
_dbus_string_free (&header->data);
}
| 5,795 |
148,069 | 0 |
static void VoidMethodDefaultUndefinedLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exception_state(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDefaultUndefinedLongArg");
TestObject* impl = V8TestObject::ToImpl(info.Holder());
int32_t default_undefined_long_arg;
default_undefined_long_arg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exception_state);
if (exception_state.HadException())
return;
impl->voidMethodDefaultUndefinedLongArg(default_undefined_long_arg);
}
| 5,796 |
127,963 | 0 |
void BrowserViewRenderer::SetViewVisibility(bool view_visible) {
TRACE_EVENT_INSTANT1("android_webview",
"BrowserViewRenderer::SetViewVisibility",
TRACE_EVENT_SCOPE_THREAD,
"view_visible",
view_visible);
view_visible_ = view_visible;
if (!disable_page_visibility_)
UpdateCompositorIsActive();
}
| 5,797 |
89,271 | 0 |
ModuleExport void UnregisterTIFFImage(void)
{
(void) UnregisterMagickInfo("TIFF64");
(void) UnregisterMagickInfo("TIFF");
(void) UnregisterMagickInfo("TIF");
(void) UnregisterMagickInfo("PTIF");
#if defined(MAGICKCORE_TIFF_DELEGATE)
if (tiff_semaphore == (SemaphoreInfo *) NULL)
ActivateSemaphoreInfo(&tiff_semaphore);
LockSemaphoreInfo(tiff_semaphore);
if (instantiate_key != MagickFalse)
{
#if defined(MAGICKCORE_HAVE_TIFFMERGEFIELDINFO) && defined(MAGICKCORE_HAVE_TIFFSETTAGEXTENDER)
if (tag_extender == (TIFFExtendProc) NULL)
(void) TIFFSetTagExtender(tag_extender);
#endif
if (DeleteMagickThreadKey(tiff_exception) == MagickFalse)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) TIFFSetWarningHandler(warning_handler);
(void) TIFFSetErrorHandler(error_handler);
instantiate_key=MagickFalse;
}
UnlockSemaphoreInfo(tiff_semaphore);
RelinquishSemaphoreInfo(&tiff_semaphore);
#endif
}
| 5,798 |
42,083 | 0 |
mm_answer_audit_command(int socket, Buffer *m)
{
u_int len;
char *cmd;
debug3("%s entering", __func__);
cmd = buffer_get_string(m, &len);
/* sanity check command, if so how? */
audit_run_command(cmd);
free(cmd);
return (0);
}
| 5,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.