unique_id
int64 13
189k
| target
int64 0
1
| code
stringlengths 20
241k
| __index_level_0__
int64 0
18.9k
|
|---|---|---|---|
24,239 | 0 | ar6000_unavail_ev(void *context, void *hif_handle)
{
struct ar6_softc *ar = (struct ar6_softc *)context;
/* NULL out it's entry in the global list */
ar6000_devices[ar->arDeviceIndex] = NULL;
ar6000_destroy(ar->arNetDev, 1);
return 0;
}
| 3,300 |
120,909 | 0 | FactoryForIsolatedMedia(
const ProfileIOData* profile_io_data,
const StoragePartitionDescriptor& partition_descriptor,
ChromeURLRequestContextGetter* app_context)
: profile_io_data_(profile_io_data),
partition_descriptor_(partition_descriptor),
app_context_getter_(app_context) {}
| 3,301 |
22,779 | 0 | void nfs4_clear_inode(struct inode *inode)
{
/* If we are holding a delegation, return it! */
nfs_inode_return_delegation_noreclaim(inode);
/* First call standard NFS clear_inode() code */
nfs_clear_inode(inode);
}
| 3,302 |
44,146 | 0 | void pipe_lock(struct pipe_inode_info *pipe)
{
/*
* pipe_lock() nests non-pipe inode locks (for writing to a file)
*/
pipe_lock_nested(pipe, I_MUTEX_PARENT);
}
| 3,303 |
20,291 | 0 | static int kvm_iommu_map_memslots(struct kvm *kvm)
{
int idx, r = 0;
struct kvm_memslots *slots;
struct kvm_memory_slot *memslot;
idx = srcu_read_lock(&kvm->srcu);
slots = kvm_memslots(kvm);
kvm_for_each_memslot(memslot, slots) {
r = kvm_iommu_map_pages(kvm, memslot);
if (r)
break;
}
srcu_read_unlock(&kvm->srcu, idx);
return r;
}
| 3,304 |
139,169 | 0 | bool RenderProcessHostImpl::HasConnection() const {
return is_initialized_ && !is_dead_;
}
| 3,305 |
143,403 | 0 | Job::~Job() {
DCHECK(!pending_dns_);
DCHECK(callback_.is_null());
DCHECK(!bindings_);
}
| 3,306 |
92,509 | 0 | static void cpu_load_update(struct rq *this_rq, unsigned long this_load,
unsigned long pending_updates)
{
unsigned long __maybe_unused tickless_load = this_rq->cpu_load[0];
int i, scale;
this_rq->nr_load_updates++;
/* Update our load: */
this_rq->cpu_load[0] = this_load; /* Fasttrack for idx 0 */
for (i = 1, scale = 2; i < CPU_LOAD_IDX_MAX; i++, scale += scale) {
unsigned long old_load, new_load;
/* scale is effectively 1 << i now, and >> i divides by scale */
old_load = this_rq->cpu_load[i];
#ifdef CONFIG_NO_HZ_COMMON
old_load = decay_load_missed(old_load, pending_updates - 1, i);
if (tickless_load) {
old_load -= decay_load_missed(tickless_load, pending_updates - 1, i);
/*
* old_load can never be a negative value because a
* decayed tickless_load cannot be greater than the
* original tickless_load.
*/
old_load += tickless_load;
}
#endif
new_load = this_load;
/*
* Round up the averaging division if load is increasing. This
* prevents us from getting stuck on 9 if the load is 10, for
* example.
*/
if (new_load > old_load)
new_load += scale - 1;
this_rq->cpu_load[i] = (old_load * (scale - 1) + new_load) >> i;
}
}
| 3,307 |
41,580 | 0 | static void irda_disconnect_indication(void *instance, void *sap,
LM_REASON reason, struct sk_buff *skb)
{
struct irda_sock *self;
struct sock *sk;
self = instance;
pr_debug("%s(%p)\n", __func__, self);
/* Don't care about it, but let's not leak it */
if(skb)
dev_kfree_skb(skb);
sk = instance;
if (sk == NULL) {
pr_debug("%s(%p) : BUG : sk is NULL\n",
__func__, self);
return;
}
/* Prevent race conditions with irda_release() and irda_shutdown() */
bh_lock_sock(sk);
if (!sock_flag(sk, SOCK_DEAD) && sk->sk_state != TCP_CLOSE) {
sk->sk_state = TCP_CLOSE;
sk->sk_shutdown |= SEND_SHUTDOWN;
sk->sk_state_change(sk);
/* Close our TSAP.
* If we leave it open, IrLMP put it back into the list of
* unconnected LSAPs. The problem is that any incoming request
* can then be matched to this socket (and it will be, because
* it is at the head of the list). This would prevent any
* listening socket waiting on the same TSAP to get those
* requests. Some apps forget to close sockets, or hang to it
* a bit too long, so we may stay in this dead state long
* enough to be noticed...
* Note : all socket function do check sk->sk_state, so we are
* safe...
* Jean II
*/
if (self->tsap) {
irttp_close_tsap(self->tsap);
self->tsap = NULL;
}
}
bh_unlock_sock(sk);
/* Note : once we are there, there is not much you want to do
* with the socket anymore, apart from closing it.
* For example, bind() and connect() won't reset sk->sk_err,
* sk->sk_shutdown and sk->sk_flags to valid values...
* Jean II
*/
}
| 3,308 |
114,387 | 0 | void GpuCommandBufferStub::OnCommandProcessed() {
if (watchdog_)
watchdog_->CheckArmed();
}
| 3,309 |
10,959 | 0 | static signed short php_ifd_get16s(void *value, int motorola_intel)
{
return (signed short)php_ifd_get16u(value, motorola_intel);
}
| 3,310 |
130,491 | 0 | bool AsyncReadPixelsCompletedQuery::End(base::subtle::Atomic32 submit_count) {
if (!AddToPendingQueue(submit_count)) {
return false;
}
manager()->decoder()->WaitForReadPixels(
base::Bind(&AsyncReadPixelsCompletedQuery::Complete,
AsWeakPtr()));
return true;
}
| 3,311 |
8,282 | 0 | short *XRRConfigRates (XRRScreenConfiguration *config, int sizeID, int *nrates)
{
short *r = config->rates;
int nents = config->nrates;
/* Skip over the intervening rate lists */
while (sizeID > 0 && nents > 0)
{
int i = (*r + 1);
r += i;
nents -= i;
sizeID--;
}
if (!nents)
{
*nrates = 0;
return NULL;
}
*nrates = (int) *r;
return r + 1;
}
| 3,312 |
42,407 | 0 | max_corrected_read_errors_show(struct mddev *mddev, char *page) {
return sprintf(page, "%d\n",
atomic_read(&mddev->max_corr_read_errors));
}
| 3,313 |
144,938 | 0 | bool RenderWidgetHostViewAura::NeedsMouseCapture() {
#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
return NeedsInputGrab();
#endif
return false;
}
| 3,314 |
80,615 | 0 | GF_Err trun_Read(GF_Box *s, GF_BitStream *bs)
{
u32 i;
GF_TrunEntry *p;
GF_TrackFragmentRunBox *ptr = (GF_TrackFragmentRunBox *)s;
if ((ptr->flags & GF_ISOM_TRUN_FIRST_FLAG) && (ptr->flags & GF_ISOM_TRUN_FLAGS))
return GF_ISOM_INVALID_FILE;
ptr->sample_count = gf_bs_read_u32(bs);
if (ptr->flags & GF_ISOM_TRUN_DATA_OFFSET) {
ptr->data_offset = gf_bs_read_u32(bs);
ISOM_DECREASE_SIZE(ptr, 4);
}
if (ptr->flags & GF_ISOM_TRUN_FIRST_FLAG) {
ptr->first_sample_flags = gf_bs_read_u32(bs);
ISOM_DECREASE_SIZE(ptr, 4);
}
for (i=0; i<ptr->sample_count; i++) {
u32 trun_size = 0;
p = (GF_TrunEntry *) gf_malloc(sizeof(GF_TrunEntry));
if (!p) return GF_OUT_OF_MEM;
memset(p, 0, sizeof(GF_TrunEntry));
if (ptr->flags & GF_ISOM_TRUN_DURATION) {
p->Duration = gf_bs_read_u32(bs);
trun_size += 4;
}
if (ptr->flags & GF_ISOM_TRUN_SIZE) {
p->size = gf_bs_read_u32(bs);
trun_size += 4;
}
if (ptr->flags & GF_ISOM_TRUN_FLAGS) {
p->flags = gf_bs_read_u32(bs);
trun_size += 4;
}
if (ptr->flags & GF_ISOM_TRUN_CTS_OFFSET) {
if (ptr->version==0) {
p->CTS_Offset = (u32) gf_bs_read_u32(bs);
} else {
p->CTS_Offset = (s32) gf_bs_read_u32(bs);
}
}
gf_list_add(ptr->entries, p);
ISOM_DECREASE_SIZE(ptr, trun_size);
}
return GF_OK;
}
| 3,315 |
114,748 | 0 | void PPAPITestBase::RunTestAndReload(const std::string& test_case) {
GURL url = GetTestFileUrl(test_case);
RunTestURL(url);
RunTestURL(url);
}
| 3,316 |
10,011 | 0 | event_grid_reset( GridStatus st )
{
st->x_origin = st->x_origin_0;
st->y_origin = st->y_origin_0;
st->scale = st->scale_0;
}
| 3,317 |
162,138 | 0 | void RenderProcessHostImpl::RemoveWidget(RenderWidgetHost* widget) {
RenderWidgetHostImpl* widget_impl =
static_cast<RenderWidgetHostImpl*>(widget);
widgets_.erase(widget_impl);
#if defined(OS_ANDROID)
ChildProcessImportance importance = widget_impl->importance();
DCHECK(widget_importance_counts_[static_cast<size_t>(importance)]);
widget_importance_counts_[static_cast<size_t>(importance)]--;
UpdateProcessPriority();
#endif
}
| 3,318 |
4,780 | 0 | stringprep_4zi_1 (uint32_t * ucs4, size_t ucs4len, size_t maxucs4len,
Stringprep_profile_flags flags,
const Stringprep_profile * profile)
{
int rc;
rc = stringprep_4i (ucs4, &ucs4len, maxucs4len, flags, profile);
if (rc != STRINGPREP_OK)
return rc;
if (ucs4len >= maxucs4len)
return STRINGPREP_TOO_SMALL_BUFFER;
ucs4[ucs4len] = 0;
return STRINGPREP_OK;
}
| 3,319 |
49,176 | 0 | static int packet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
{
struct sockaddr_ll *sll = (struct sockaddr_ll *)uaddr;
struct sock *sk = sock->sk;
/*
* Check legality
*/
if (addr_len < sizeof(struct sockaddr_ll))
return -EINVAL;
if (sll->sll_family != AF_PACKET)
return -EINVAL;
return packet_do_bind(sk, NULL, sll->sll_ifindex,
sll->sll_protocol ? : pkt_sk(sk)->num);
}
| 3,320 |
77,278 | 0 | next_learn_with_delete(const struct rule_actions *actions,
const struct ofpact_learn *start)
{
const struct ofpact *pos;
for (pos = start ? ofpact_next(&start->ofpact) : actions->ofpacts;
pos < ofpact_end(actions->ofpacts, actions->ofpacts_len);
pos = ofpact_next(pos)) {
if (pos->type == OFPACT_LEARN) {
const struct ofpact_learn *learn = ofpact_get_LEARN(pos);
if (learn->flags & NX_LEARN_F_DELETE_LEARNED) {
return learn;
}
}
}
return NULL;
}
| 3,321 |
120,946 | 0 | int SocketStream::DoSSLHandleCertError(int result) {
DCHECK_EQ(STATE_NONE, next_state_);
DCHECK(IsCertificateError(result));
result = HandleCertificateError(result);
if (result == OK || result == ERR_IO_PENDING)
next_state_ = STATE_SSL_HANDLE_CERT_ERROR_COMPLETE;
else
next_state_ = STATE_CLOSE;
return result;
}
| 3,322 |
142,967 | 0 | void HTMLMediaElement::setCurrentTime(double time) {
if (ready_state_ == kHaveNothing) {
default_playback_start_position_ = time;
return;
}
Seek(time);
}
| 3,323 |
137,421 | 0 | NavigatorServiceWorker& NavigatorServiceWorker::from(Navigator& navigator)
{
NavigatorServiceWorker* supplement = toNavigatorServiceWorker(navigator);
if (!supplement) {
supplement = new NavigatorServiceWorker(navigator);
provideTo(navigator, supplementName(), supplement);
if (navigator.frame() && navigator.frame()->securityContext()->securityOrigin()->canAccessServiceWorkers()) {
supplement->serviceWorker(ASSERT_NO_EXCEPTION);
}
}
return *supplement;
}
| 3,324 |
168,876 | 0 | void RenderFrameDevToolsAgentHost::OnNavigationRequestFailed(
const NavigationRequest& nav_request,
int error_code) {
FrameTreeNode* ftn = nav_request.frame_tree_node();
std::string id = nav_request.devtools_navigation_token().ToString();
DispatchToAgents(ftn, &protocol::NetworkHandler::LoadingComplete, id,
protocol::Page::ResourceTypeEnum::Document,
network::URLLoaderCompletionStatus(error_code));
}
| 3,325 |
3,149 | 0 | static int setlabspace(i_ctx_t * i_ctx_p, ref *r, int *stage, int *cont,
int CIESubst)
{
/* In this case, we will treat this as an ICC color space, with a
CIELAB 16 bit profile */
ref labdict;
int code = 0;
float range_buff[4], white[3], black[3];
static const float dflt_range[4] = { -100, 100, -100, 100 };
static const float dflt_black[3] = {0,0,0}, dflt_white[3] = {0,0,0};
int i;
gs_client_color cc;
*cont = 0;
code = array_get(imemory, r, 1, &labdict);
if (code < 0)
return code;
/* Get all the parts */
code = dict_floats_param( imemory, &labdict, "Range", 4, range_buff,
dflt_range );
if (code < 0)
return code;
for (i = 0; i < 4 && range_buff[i + 1] >= range_buff[i]; i += 2);
if (i != 4)
return_error(gs_error_rangecheck);
code = dict_floats_param( imemory, &labdict, "BlackPoint", 3, black,
dflt_black );
if (code < 0)
return code;
code = dict_floats_param( imemory, &labdict, "WhitePoint", 3, white,
dflt_white );
if (code < 0)
return code;
if (white[0] <= 0 || white[1] != 1.0 || white[2] <= 0)
return_error(gs_error_rangecheck);
code = seticc_lab(i_ctx_p, white, black, range_buff);
if ( code < 0)
return gs_rethrow(code, "setting PDF lab color space");
cc.pattern = 0x00;
for (i=0;i<3;i++)
cc.paint.values[i] = 0;
code = gs_setcolor(igs, &cc);
return code;
}
| 3,326 |
69,040 | 0 | static MagickBooleanType ApplyPSDOpacityMask(Image *image,const Image *mask,
Quantum background,MagickBooleanType revert,ExceptionInfo *exception)
{
Image
*complete_mask;
MagickBooleanType
status;
PixelInfo
color;
ssize_t
y;
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" applying opacity mask");
complete_mask=CloneImage(image,image->columns,image->rows,MagickTrue,
exception);
complete_mask->alpha_trait=BlendPixelTrait;
GetPixelInfo(complete_mask,&color);
color.red=background;
SetImageColor(complete_mask,&color,exception);
status=CompositeImage(complete_mask,mask,OverCompositeOp,MagickTrue,
mask->page.x-image->page.x,mask->page.y-image->page.y,exception);
if (status == MagickFalse)
{
complete_mask=DestroyImage(complete_mask);
return(status);
}
image->alpha_trait=BlendPixelTrait;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
*magick_restrict q;
register Quantum
*p;
register ssize_t
x;
if (status == MagickFalse)
continue;
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
p=GetAuthenticPixels(complete_mask,0,y,complete_mask->columns,1,exception);
if ((q == (Quantum *) NULL) || (p == (Quantum *) NULL))
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
MagickRealType
alpha,
intensity;
alpha=GetPixelAlpha(image,q);
intensity=GetPixelIntensity(complete_mask,p);
if (revert == MagickFalse)
SetPixelAlpha(image,ClampToQuantum(intensity*(QuantumScale*alpha)),q);
else if (intensity > 0)
SetPixelAlpha(image,ClampToQuantum((alpha/intensity)*QuantumRange),q);
q+=GetPixelChannels(image);
p+=GetPixelChannels(complete_mask);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
status=MagickFalse;
}
complete_mask=DestroyImage(complete_mask);
return(status);
}
| 3,327 |
98,235 | 0 | __attribute__((visibility("default"))) int TestDummyEntrypoint() {
return test_dummy::TestDummy();
}
| 3,328 |
175,904 | 0 | void smp_br_pairing_complete(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
SMP_TRACE_DEBUG("%s", __func__);
if (p_cb->total_tx_unacked == 0) {
/* process the pairing complete */
smp_proc_pairing_cmpl(p_cb);
}
}
| 3,329 |
14,242 | 0 | static PHP_MINIT_FUNCTION(libxml)
{
zend_class_entry ce;
php_libxml_initialize();
REGISTER_LONG_CONSTANT("LIBXML_VERSION", LIBXML_VERSION, CONST_CS | CONST_PERSISTENT);
REGISTER_STRING_CONSTANT("LIBXML_DOTTED_VERSION", LIBXML_DOTTED_VERSION, CONST_CS | CONST_PERSISTENT);
REGISTER_STRING_CONSTANT("LIBXML_LOADED_VERSION", (char *)xmlParserVersion, CONST_CS | CONST_PERSISTENT);
/* For use with loading xml */
REGISTER_LONG_CONSTANT("LIBXML_NOENT", XML_PARSE_NOENT, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_DTDLOAD", XML_PARSE_DTDLOAD, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_DTDATTR", XML_PARSE_DTDATTR, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_DTDVALID", XML_PARSE_DTDVALID, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_NOERROR", XML_PARSE_NOERROR, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_NOWARNING", XML_PARSE_NOWARNING, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_NOBLANKS", XML_PARSE_NOBLANKS, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_XINCLUDE", XML_PARSE_XINCLUDE, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_NSCLEAN", XML_PARSE_NSCLEAN, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_NOCDATA", XML_PARSE_NOCDATA, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_NONET", XML_PARSE_NONET, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_PEDANTIC", XML_PARSE_PEDANTIC, CONST_CS | CONST_PERSISTENT);
#if LIBXML_VERSION >= 20621
REGISTER_LONG_CONSTANT("LIBXML_COMPACT", XML_PARSE_COMPACT, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_NOXMLDECL", XML_SAVE_NO_DECL, CONST_CS | CONST_PERSISTENT);
#endif
#if LIBXML_VERSION >= 20703
REGISTER_LONG_CONSTANT("LIBXML_PARSEHUGE", XML_PARSE_HUGE, CONST_CS | CONST_PERSISTENT);
#endif
REGISTER_LONG_CONSTANT("LIBXML_NOEMPTYTAG", LIBXML_SAVE_NOEMPTYTAG, CONST_CS | CONST_PERSISTENT);
/* Schema validation options */
#if defined(LIBXML_SCHEMAS_ENABLED) && LIBXML_VERSION >= 20614
REGISTER_LONG_CONSTANT("LIBXML_SCHEMA_CREATE", XML_SCHEMA_VAL_VC_I_CREATE, CONST_CS | CONST_PERSISTENT);
#endif
/* Additional constants for use with loading html */
#if LIBXML_VERSION >= 20707
REGISTER_LONG_CONSTANT("LIBXML_HTML_NOIMPLIED", HTML_PARSE_NOIMPLIED, CONST_CS | CONST_PERSISTENT);
#endif
#if LIBXML_VERSION >= 20708
REGISTER_LONG_CONSTANT("LIBXML_HTML_NODEFDTD", HTML_PARSE_NODEFDTD, CONST_CS | CONST_PERSISTENT);
#endif
/* Error levels */
REGISTER_LONG_CONSTANT("LIBXML_ERR_NONE", XML_ERR_NONE, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_ERR_WARNING", XML_ERR_WARNING, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_ERR_ERROR", XML_ERR_ERROR, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("LIBXML_ERR_FATAL", XML_ERR_FATAL, CONST_CS | CONST_PERSISTENT);
INIT_CLASS_ENTRY(ce, "LibXMLError", NULL);
libxmlerror_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
if (sapi_module.name) {
static const char * const supported_sapis[] = {
"cgi-fcgi",
"fpm-fcgi",
"litespeed",
NULL
};
const char * const *sapi_name;
for (sapi_name = supported_sapis; *sapi_name; sapi_name++) {
if (strcmp(sapi_module.name, *sapi_name) == 0) {
_php_libxml_per_request_initialization = 0;
break;
}
}
}
if (!_php_libxml_per_request_initialization) {
/* report errors via handler rather than stderr */
xmlSetGenericErrorFunc(NULL, php_libxml_error_handler);
xmlParserInputBufferCreateFilenameDefault(php_libxml_input_buffer_create_filename);
xmlOutputBufferCreateFilenameDefault(php_libxml_output_buffer_create_filename);
}
return SUCCESS;
}
| 3,330 |
141,426 | 0 | int PaintLayerScrollableArea::HorizontalScrollbarHeight(
OverlayScrollbarClipBehavior overlay_scrollbar_clip_behavior) const {
if (!HasHorizontalScrollbar())
return 0;
if (overlay_scrollbar_clip_behavior ==
kIgnorePlatformAndCSSOverlayScrollbarSize &&
GetLayoutBox()->StyleRef().OverflowX() == EOverflow::kOverlay) {
return 0;
}
if ((overlay_scrollbar_clip_behavior == kIgnorePlatformOverlayScrollbarSize ||
overlay_scrollbar_clip_behavior ==
kIgnorePlatformAndCSSOverlayScrollbarSize ||
!HorizontalScrollbar()->ShouldParticipateInHitTesting()) &&
HorizontalScrollbar()->IsOverlayScrollbar()) {
return 0;
}
return HorizontalScrollbar()->ScrollbarThickness();
}
| 3,331 |
8,740 | 0 | vcard_init_buffer_response(VCard *card, unsigned char *buf, int len)
{
VCardResponse *response;
VCardBufferResponse *buffer_response;
buffer_response = vcard_get_buffer_response(card);
if (buffer_response) {
vcard_set_buffer_response(card, NULL);
vcard_buffer_response_delete(buffer_response);
}
buffer_response = vcard_buffer_response_new(buf, len);
if (buffer_response == NULL) {
return NULL;
}
response = vcard_response_new_status_bytes(VCARD7816_SW1_RESPONSE_BYTES,
len > 255 ? 0 : len);
if (response == NULL) {
return NULL;
}
vcard_set_buffer_response(card, buffer_response);
return response;
}
| 3,332 |
4,267 | 0 | PHP_FUNCTION(error_log)
{
char *message, *opt = NULL, *headers = NULL;
int message_len, opt_len = 0, headers_len = 0;
int opt_err = 0, argc = ZEND_NUM_ARGS();
long erropt = 0;
if (zend_parse_parameters(argc TSRMLS_CC, "s|lps", &message, &message_len, &erropt, &opt, &opt_len, &headers, &headers_len) == FAILURE) {
return;
}
if (argc > 1) {
opt_err = erropt;
}
if (_php_error_log_ex(opt_err, message, message_len, opt, headers TSRMLS_CC) == FAILURE) {
RETURN_FALSE;
}
RETURN_TRUE;
}
| 3,333 |
58,460 | 0 | server_stopconnecting (server * serv)
{
if (serv->iotag)
{
fe_input_remove (serv->iotag);
serv->iotag = 0;
}
if (serv->joindelay_tag)
{
fe_timeout_remove (serv->joindelay_tag);
serv->joindelay_tag = 0;
}
#ifndef WIN32
/* kill the child process trying to connect */
kill (serv->childpid, SIGKILL);
waitpid (serv->childpid, NULL, 0);
close (serv->childwrite);
close (serv->childread);
#else
PostThreadMessage (serv->childpid, WM_QUIT, 0, 0);
{
/* if we close the pipe now, giowin32 will crash. */
int *pipefd = malloc (sizeof (int) * 2);
pipefd[0] = serv->childwrite;
pipefd[1] = serv->childread;
g_idle_add ((GSourceFunc)server_close_pipe, pipefd);
}
#endif
#ifdef USE_OPENSSL
if (serv->ssl_do_connect_tag)
{
fe_timeout_remove (serv->ssl_do_connect_tag);
serv->ssl_do_connect_tag = 0;
}
#endif
fe_progressbar_end (serv);
serv->connecting = FALSE;
fe_server_event (serv, FE_SE_DISCONNECT, 0);
}
| 3,334 |
155,963 | 0 | void DiceTurnSyncOnHelper::CompleteInitForNewProfile(
Profile* new_profile,
Profile::CreateStatus status) {
DCHECK_NE(profile_, new_profile);
switch (status) {
case Profile::CREATE_STATUS_LOCAL_FAIL:
NOTREACHED() << "Error creating new profile";
AbortAndDelete();
break;
case Profile::CREATE_STATUS_CREATED:
break;
case Profile::CREATE_STATUS_INITIALIZED:
delegate_->ShowSigninPageInNewProfile(new_profile, account_info_.email);
AbortAndDelete();
break;
case Profile::CREATE_STATUS_REMOTE_FAIL:
case Profile::CREATE_STATUS_CANCELED:
case Profile::MAX_CREATE_STATUS: {
NOTREACHED() << "Invalid profile creation status";
AbortAndDelete();
break;
}
}
}
| 3,335 |
169,676 | 0 | bool SiteInstanceImpl::IsSameWebSite(BrowserContext* browser_context,
const GURL& real_src_url,
const GURL& real_dest_url,
bool should_compare_effective_urls) {
GURL src_url =
should_compare_effective_urls
? SiteInstanceImpl::GetEffectiveURL(browser_context, real_src_url)
: real_src_url;
GURL dest_url =
should_compare_effective_urls
? SiteInstanceImpl::GetEffectiveURL(browser_context, real_dest_url)
: real_dest_url;
if (IsRendererDebugURL(src_url) || IsRendererDebugURL(dest_url))
return true;
if (!src_url.is_valid() || !dest_url.is_valid())
return false;
GURL blank_page(url::kAboutBlankURL);
if (dest_url == blank_page)
return true;
if (src_url.EqualsIgnoringRef(dest_url))
return true;
url::Origin src_origin = url::Origin::Create(src_url);
url::Origin dest_origin = url::Origin::Create(dest_url);
if (src_origin.scheme() != dest_origin.scheme())
return false;
if (!net::registry_controlled_domains::SameDomainOrHost(
src_origin, dest_origin,
net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES)) {
return false;
}
if (src_origin == dest_origin)
return true;
auto* policy = ChildProcessSecurityPolicyImpl::GetInstance();
url::Origin src_isolated_origin;
url::Origin dest_isolated_origin;
bool src_origin_is_isolated =
policy->GetMatchingIsolatedOrigin(src_origin, &src_isolated_origin);
bool dest_origin_is_isolated =
policy->GetMatchingIsolatedOrigin(dest_origin, &dest_isolated_origin);
if (src_origin_is_isolated || dest_origin_is_isolated) {
return src_isolated_origin == dest_isolated_origin;
}
return true;
}
| 3,336 |
182,898 | 1 | int ipmi_destroy_user(struct ipmi_user *user)
{
_ipmi_destroy_user(user);
cleanup_srcu_struct(&user->release_barrier);
kref_put(&user->refcount, free_user);
return 0;
}
| 3,337 |
188,027 | 1 | void SkippedMBMotionComp(
VideoDecData *video
)
{
Vop *prev = video->prevVop;
Vop *comp;
int ypos, xpos;
PIXEL *c_comp, *c_prev;
PIXEL *cu_comp, *cu_prev;
PIXEL *cv_comp, *cv_prev;
int width, width_uv;
int32 offset;
#ifdef PV_POSTPROC_ON // 2/14/2001
int imv;
int32 size = (int32) video->nTotalMB << 8;
uint8 *pp_dec_y, *pp_dec_u;
uint8 *pp_prev1;
int mvwidth = video->nMBPerRow << 1;
#endif
width = video->width;
width_uv = width >> 1;
ypos = video->mbnum_row << 4 ;
xpos = video->mbnum_col << 4 ;
offset = (int32)ypos * width + xpos;
/* zero motion compensation for previous frame */
/*mby*width + mbx;*/
c_prev = prev->yChan + offset;
/*by*width_uv + bx;*/
cu_prev = prev->uChan + (offset >> 2) + (xpos >> 2);
/*by*width_uv + bx;*/
cv_prev = prev->vChan + (offset >> 2) + (xpos >> 2);
comp = video->currVop;
c_comp = comp->yChan + offset;
cu_comp = comp->uChan + (offset >> 2) + (xpos >> 2);
cv_comp = comp->vChan + (offset >> 2) + (xpos >> 2);
/* Copy previous reconstructed frame into the current frame */
PutSKIPPED_MB(c_comp, c_prev, width);
PutSKIPPED_B(cu_comp, cu_prev, width_uv);
PutSKIPPED_B(cv_comp, cv_prev, width_uv);
/* 10/24/2000 post_processing semaphore generation */
#ifdef PV_POSTPROC_ON // 2/14/2001
if (video->postFilterType != PV_NO_POST_PROC)
{
imv = (offset >> 6) - (xpos >> 6) + (xpos >> 3);
/* Post-processing mode (copy previous MB) */
pp_prev1 = video->pstprcTypPrv + imv;
pp_dec_y = video->pstprcTypCur + imv;
*pp_dec_y = *pp_prev1;
*(pp_dec_y + 1) = *(pp_prev1 + 1);
*(pp_dec_y + mvwidth) = *(pp_prev1 + mvwidth);
*(pp_dec_y + mvwidth + 1) = *(pp_prev1 + mvwidth + 1);
/* chrominance */
/*4*MB_in_width*MB_in_height*/
pp_prev1 = video->pstprcTypPrv + (size >> 6) +
((imv + (xpos >> 3)) >> 2);
pp_dec_u = video->pstprcTypCur + (size >> 6) +
((imv + (xpos >> 3)) >> 2);
*pp_dec_u = *pp_prev1;
pp_dec_u[size>>8] = pp_prev1[size>>8];
}
#endif
/*----------------------------------------------------------------------------
; Return nothing or data or data pointer
----------------------------------------------------------------------------*/
return;
}
| 3,338 |
18,939 | 0 | int ip_setsockopt(struct sock *sk, int level,
int optname, char __user *optval, unsigned int optlen)
{
int err;
if (level != SOL_IP)
return -ENOPROTOOPT;
err = do_ip_setsockopt(sk, level, optname, optval, optlen);
#ifdef CONFIG_NETFILTER
/* we need to exclude all possible ENOPROTOOPTs except default case */
if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
optname != IP_IPSEC_POLICY &&
optname != IP_XFRM_POLICY &&
!ip_mroute_opt(optname)) {
lock_sock(sk);
err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
release_sock(sk);
}
#endif
return err;
}
| 3,339 |
139,325 | 0 | FloatRect HarfBuzzShaper::selectionRect(const FloatPoint& point, int height, int from, int to)
{
float currentX = 0;
float fromX = 0;
float toX = 0;
bool foundFromX = false;
bool foundToX = false;
if (m_run.rtl())
currentX = m_totalWidth;
for (unsigned i = 0; i < m_harfBuzzRuns.size(); ++i) {
if (m_run.rtl())
currentX -= m_harfBuzzRuns[i]->width();
int numCharacters = m_harfBuzzRuns[i]->numCharacters();
if (!foundFromX && from >= 0 && from < numCharacters) {
fromX = m_harfBuzzRuns[i]->xPositionForOffset(from) + currentX;
foundFromX = true;
} else {
from -= numCharacters;
}
if (!foundToX && to >= 0 && to < numCharacters) {
toX = m_harfBuzzRuns[i]->xPositionForOffset(to) + currentX;
foundToX = true;
} else {
to -= numCharacters;
}
if (foundFromX && foundToX)
break;
if (!m_run.rtl())
currentX += m_harfBuzzRuns[i]->width();
}
if (!foundFromX)
fromX = 0;
if (!foundToX)
toX = m_run.rtl() ? 0 : m_totalWidth;
if (!foundToX && !foundFromX)
fromX = toX = 0;
if (fromX < toX)
return FloatRect(point.x() + fromX, point.y(), toX - fromX, height);
return FloatRect(point.x() + toX, point.y(), fromX - toX, height);
}
| 3,340 |
179,453 | 1 | static int do_new_mount(struct path *path, const char *fstype, int flags,
int mnt_flags, const char *name, void *data)
{
struct file_system_type *type;
struct user_namespace *user_ns = current->nsproxy->mnt_ns->user_ns;
struct vfsmount *mnt;
int err;
if (!fstype)
return -EINVAL;
type = get_fs_type(fstype);
if (!type)
return -ENODEV;
if (user_ns != &init_user_ns) {
if (!(type->fs_flags & FS_USERNS_MOUNT)) {
put_filesystem(type);
return -EPERM;
}
/* Only in special cases allow devices from mounts
* created outside the initial user namespace.
*/
if (!(type->fs_flags & FS_USERNS_DEV_MOUNT)) {
flags |= MS_NODEV;
mnt_flags |= MNT_NODEV;
}
}
mnt = vfs_kern_mount(type, flags, name, data);
if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
!mnt->mnt_sb->s_subtype)
mnt = fs_set_subtype(mnt, fstype);
put_filesystem(type);
if (IS_ERR(mnt))
return PTR_ERR(mnt);
err = do_add_mount(real_mount(mnt), path, mnt_flags);
if (err)
mntput(mnt);
return err;
}
| 3,341 |
137,285 | 0 | void Textfield::SetCursorEnabled(bool enabled) {
if (GetRenderText()->cursor_enabled() == enabled)
return;
GetRenderText()->SetCursorEnabled(enabled);
UpdateCursorViewPosition();
UpdateCursorVisibility();
}
| 3,342 |
122,069 | 0 | void ProfileDependencyManager::DestroyProfileServices(Profile* profile) {
if (destruction_order_.empty())
BuildDestructionOrder(profile);
for (std::vector<ProfileKeyedBaseFactory*>::const_iterator it =
destruction_order_.begin(); it != destruction_order_.end(); ++it) {
(*it)->ProfileShutdown(profile);
}
#ifndef NDEBUG
dead_profile_pointers_.insert(profile);
#endif
for (std::vector<ProfileKeyedBaseFactory*>::const_iterator it =
destruction_order_.begin(); it != destruction_order_.end(); ++it) {
(*it)->ProfileDestroyed(profile);
}
}
| 3,343 |
161,206 | 0 | static bool IsOfficeType(const std::string& type_hint) {
return (type_hint == "application/msword" ||
type_hint == "application/vnd.ms-excel" ||
type_hint == "application/vnd.ms-powerpoint" ||
type_hint == "application/vnd.openxmlformats-officedocument."
"wordprocessingml.document" ||
type_hint == "application/vnd.openxmlformats-officedocument."
"spreadsheetml.sheet" ||
type_hint == "application/vnd.openxmlformats-officedocument."
"presentationml.presentation" ||
type_hint == "application/vnd.ms-excel.sheet.macroenabled.12" ||
type_hint == "application/vnd.ms-word.document.macroenabled.12" ||
type_hint == "application/vnd.ms-powerpoint.presentation."
"macroenabled.12" ||
type_hint == "application/mspowerpoint" ||
type_hint == "application/msexcel" ||
type_hint == "application/vnd.ms-word" ||
type_hint == "application/vnd.ms-word.document.12" ||
type_hint == "application/vnd.msword");
}
| 3,344 |
13,625 | 0 | static int ebcdic_gets(BIO *bp, char *buf, int size)
{
int i, ret = 0;
if (bp->next_bio == NULL)
return (0);
/* return(BIO_gets(bp->next_bio,buf,size));*/
for (i = 0; i < size - 1; ++i) {
ret = ebcdic_read(bp, &buf[i], 1);
if (ret <= 0)
break;
else if (buf[i] == '\n') {
++i;
break;
}
}
if (i < size)
buf[i] = '\0';
return (ret < 0 && i == 0) ? ret : i;
}
| 3,345 |
92,338 | 0 | hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table)
{
iter->p = table->v;
iter->end = iter->p + table->size;
}
| 3,346 |
160,572 | 0 | void RenderFrameImpl::DidAccessInitialDocument() {
DCHECK(!frame_->Parent());
if (!has_accessed_initial_document_) {
DocumentState* document_state =
DocumentState::FromDocumentLoader(frame_->GetDocumentLoader());
NavigationStateImpl* navigation_state =
static_cast<NavigationStateImpl*>(document_state->navigation_state());
if (!navigation_state->request_committed()) {
Send(new FrameHostMsg_DidAccessInitialDocument(routing_id_));
}
}
has_accessed_initial_document_ = true;
}
| 3,347 |
158,279 | 0 | RenderWidgetHostImpl::GetKeyboardLayoutMap() {
if (!view_)
return {};
return view_->GetKeyboardLayoutMap();
}
| 3,348 |
169,155 | 0 | void RenderFrameHostImpl::NavigateToInterstitialURL(const GURL& data_url) {
TRACE_EVENT1("navigation", "RenderFrameHostImpl::NavigateToInterstitialURL",
"frame_tree_node", frame_tree_node_->frame_tree_node_id());
DCHECK(data_url.SchemeIs(url::kDataScheme));
CommonNavigationParams common_params(
data_url, Referrer(), ui::PAGE_TRANSITION_LINK,
FrameMsg_Navigate_Type::DIFFERENT_DOCUMENT, false, false,
base::TimeTicks::Now(), FrameMsg_UILoadMetricsReportType::NO_REPORT,
GURL(), GURL(), PREVIEWS_OFF, base::TimeTicks::Now(), "GET", nullptr,
base::Optional<SourceLocation>(),
CSPDisposition::CHECK /* should_check_main_world_csp */,
false /* started_from_context_menu */, false /* has_user_gesture */,
base::nullopt /* suggested_filename */);
CommitNavigation(nullptr, network::mojom::URLLoaderClientEndpointsPtr(),
common_params, RequestNavigationParams(), false,
base::nullopt, base::nullopt /* subresource_overrides */,
base::UnguessableToken::Create() /* not traced */);
}
| 3,349 |
188,156 | 1 | status_t OMXNodeInstance::getConfig(
OMX_INDEXTYPE index, void *params, size_t /* size */) {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_GetConfig(mHandle, index, params);
OMX_INDEXEXTTYPE extIndex = (OMX_INDEXEXTTYPE)index;
if (err != OMX_ErrorNoMore) {
CLOG_IF_ERROR(getConfig, err, "%s(%#x)", asString(extIndex), index);
}
return StatusFromOMXError(err);
}
| 3,350 |
58,991 | 0 | static void CacheThru_abort(HTStream *me, HTError e)
{
if (me->fp)
LYCloseTempFP(me->fp);
if (LYCacheSourceForAborted == SOURCE_CACHE_FOR_ABORTED_DROP) {
if (me->filename) {
CTRACE((tfp, "SourceCacheWriter: Removing active file %s\n",
me->filename));
(void) LYRemoveTemp(me->filename);
FREE(me->filename);
}
if (me->chunk) {
CTRACE((tfp,
"SourceCacheWriter: Removing active memory chunk %p\n",
(void *) me->chunk));
HTChunkFree(me->chunk);
}
} else {
me->status = HT_OK; /*fake it */
CacheThru_do_free(me);
}
(*me->actions->_abort) (me->target, e);
FREE(me);
}
| 3,351 |
168,210 | 0 | void WebBluetoothServiceImpl::RequestDeviceImpl(
blink::mojom::WebBluetoothRequestDeviceOptionsPtr options,
RequestDeviceCallback callback,
device::BluetoothAdapter* adapter) {
device_chooser_controller_.reset();
device_chooser_controller_.reset(
new BluetoothDeviceChooserController(this, render_frame_host_, adapter));
auto copyable_callback = base::AdaptCallbackForRepeating(std::move(callback));
device_chooser_controller_->GetDevice(
std::move(options),
base::Bind(&WebBluetoothServiceImpl::OnGetDeviceSuccess,
weak_ptr_factory_.GetWeakPtr(), copyable_callback),
base::Bind(&WebBluetoothServiceImpl::OnGetDeviceFailed,
weak_ptr_factory_.GetWeakPtr(), copyable_callback));
}
| 3,352 |
148,147 | 0 | static void VoidMethodSequenceTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exception_state(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodSequenceTestInterfaceEmptyArg");
TestObject* impl = V8TestObject::ToImpl(info.Holder());
if (UNLIKELY(info.Length() < 1)) {
exception_state.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
return;
}
HeapVector<Member<TestInterfaceEmpty>> test_interface_empty_sequence_arg;
test_interface_empty_sequence_arg = NativeValueTraits<IDLSequence<TestInterfaceEmpty>>::NativeValue(info.GetIsolate(), info[0], exception_state);
if (exception_state.HadException())
return;
impl->voidMethodSequenceTestInterfaceEmptyArg(test_interface_empty_sequence_arg);
}
| 3,353 |
131,777 | 0 | static void testInterfaceEmptyArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)
{
TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
TestObjectPythonV8Internal::testInterfaceEmptyArrayAttributeAttributeSetter(jsValue, info);
TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
}
| 3,354 |
78,883 | 0 | static int update_private_key(const u8 *key, size_t keysize)
{
int r, idx = 0;
sc_path_t path;
r = select_app_df();
if (r)
return 1;
sc_format_path("I0012", &path);
r = sc_select_file(card, &path, NULL);
if (r) {
fprintf(stderr, "Unable to select private key file: %s\n", sc_strerror(r));
return 2;
}
idx = keysize * (opt_key_num-1);
r = sc_update_binary(card, idx, key, keysize, 0);
if (r < 0) {
fprintf(stderr, "Unable to write private key: %s\n", sc_strerror(r));
return 2;
}
return 0;
}
| 3,355 |
789 | 0 | poppler_page_get_text (PopplerPage *page,
PopplerSelectionStyle style,
PopplerRectangle *selection)
{
GooString *sel_text;
double height;
char *result;
SelectionStyle selection_style = selectionStyleGlyph;
PDFRectangle pdf_selection;
g_return_val_if_fail (POPPLER_IS_PAGE (page), FALSE);
g_return_val_if_fail (selection != NULL, NULL);
poppler_page_get_size (page, NULL, &height);
pdf_selection.x1 = selection->x1;
pdf_selection.y1 = height - selection->y2;
pdf_selection.x2 = selection->x2;
pdf_selection.y2 = height - selection->y1;
switch (style)
{
case POPPLER_SELECTION_GLYPH:
selection_style = selectionStyleGlyph;
break;
case POPPLER_SELECTION_WORD:
selection_style = selectionStyleWord;
break;
case POPPLER_SELECTION_LINE:
selection_style = selectionStyleLine;
break;
}
#if defined (HAVE_CAIRO)
TextPage *text;
text = poppler_page_get_text_page (page);
sel_text = text->getSelectionText (&pdf_selection, selection_style);
#else
TextOutputDev *text_dev;
text_dev = poppler_page_get_text_output_dev (page);
sel_text = text_dev->getSelectionText (&pdf_selection, selection_style);
#endif
result = g_strdup (sel_text->getCString ());
delete sel_text;
return result;
}
| 3,356 |
96,148 | 0 | BGD_DECLARE(gdImagePtr) gdImageClone (gdImagePtr src) {
gdImagePtr dst;
register int i, x;
if (src->trueColor) {
dst = gdImageCreateTrueColor(src->sx , src->sy);
} else {
dst = gdImageCreate(src->sx , src->sy);
}
if (dst == NULL) {
return NULL;
}
if (src->trueColor == 0) {
dst->colorsTotal = src->colorsTotal;
for (i = 0; i < gdMaxColors; i++) {
dst->red[i] = src->red[i];
dst->green[i] = src->green[i];
dst->blue[i] = src->blue[i];
dst->alpha[i] = src->alpha[i];
dst->open[i] = src->open[i];
}
for (i = 0; i < src->sy; i++) {
for (x = 0; x < src->sx; x++) {
dst->pixels[i][x] = src->pixels[i][x];
}
}
} else {
for (i = 0; i < src->sy; i++) {
for (x = 0; x < src->sx; x++) {
dst->tpixels[i][x] = src->tpixels[i][x];
}
}
}
if (src->styleLength > 0) {
dst->styleLength = src->styleLength;
dst->stylePos = src->stylePos;
for (i = 0; i < src->styleLength; i++) {
dst->style[i] = src->style[i];
}
}
dst->interlace = src->interlace;
dst->alphaBlendingFlag = src->alphaBlendingFlag;
dst->saveAlphaFlag = src->saveAlphaFlag;
dst->AA = src->AA;
dst->AA_color = src->AA_color;
dst->AA_dont_blend = src->AA_dont_blend;
dst->cx1 = src->cx1;
dst->cy1 = src->cy1;
dst->cx2 = src->cx2;
dst->cy2 = src->cy2;
dst->res_x = src->res_x;
dst->res_y = src->res_x;
dst->paletteQuantizationMethod = src->paletteQuantizationMethod;
dst->paletteQuantizationSpeed = src->paletteQuantizationSpeed;
dst->paletteQuantizationMinQuality = src->paletteQuantizationMinQuality;
dst->paletteQuantizationMinQuality = src->paletteQuantizationMinQuality;
dst->interpolation_id = src->interpolation_id;
dst->interpolation = src->interpolation;
if (src->brush) {
dst->brush = gdImageClone(src->brush);
}
if (src->tile) {
dst->tile = gdImageClone(src->tile);
}
if (src->style) {
gdImageSetStyle(dst, src->style, src->styleLength);
}
for (i = 0; i < gdMaxColors; i++) {
dst->brushColorMap[i] = src->brushColorMap[i];
dst->tileColorMap[i] = src->tileColorMap[i];
}
if (src->polyAllocated > 0) {
dst->polyAllocated = src->polyAllocated;
for (i = 0; i < src->polyAllocated; i++) {
dst->polyInts[i] = src->polyInts[i];
}
}
return dst;
}
| 3,357 |
40,525 | 0 | static bool netlink_dump_space(struct netlink_sock *nlk)
{
struct netlink_ring *ring = &nlk->rx_ring;
struct nl_mmap_hdr *hdr;
unsigned int n;
hdr = netlink_current_frame(ring, NL_MMAP_STATUS_UNUSED);
if (hdr == NULL)
return false;
n = ring->head + ring->frame_max / 2;
if (n > ring->frame_max)
n -= ring->frame_max;
hdr = __netlink_lookup_frame(ring, n);
return hdr->nm_status == NL_MMAP_STATUS_UNUSED;
}
| 3,358 |
155,641 | 0 | bool AuthenticatorWelcomeSheetModel::IsAcceptButtonVisible() const {
return true;
}
| 3,359 |
84,650 | 0 | table_close_anchor0(struct table *tbl, struct table_mode *mode)
{
if (!(mode->pre_mode & TBLM_ANCHOR))
return;
mode->pre_mode &= ~TBLM_ANCHOR;
if (tbl->tabcontentssize == mode->anchor_offset) {
check_minimum0(tbl, 1);
addcontentssize(tbl, 1);
setwidth(tbl, mode);
}
else if (tbl->linfo.prev_spaces > 0 &&
tbl->tabcontentssize - 1 == mode->anchor_offset) {
if (tbl->linfo.prev_spaces > 0)
tbl->linfo.prev_spaces = -1;
}
}
| 3,360 |
65,968 | 0 | static __be32 *xdr_check_read_list(__be32 *p, __be32 *end)
{
__be32 *next;
while (*p++ != xdr_zero) {
next = p + rpcrdma_readchunk_maxsz - 1;
if (next > end)
return NULL;
p = next;
}
return p;
}
| 3,361 |
34,185 | 0 | ip_vs_add_service(struct net *net, struct ip_vs_service_user_kern *u,
struct ip_vs_service **svc_p)
{
int ret = 0;
struct ip_vs_scheduler *sched = NULL;
struct ip_vs_pe *pe = NULL;
struct ip_vs_service *svc = NULL;
struct netns_ipvs *ipvs = net_ipvs(net);
/* increase the module use count */
ip_vs_use_count_inc();
/* Lookup the scheduler by 'u->sched_name' */
sched = ip_vs_scheduler_get(u->sched_name);
if (sched == NULL) {
pr_info("Scheduler module ip_vs_%s not found\n", u->sched_name);
ret = -ENOENT;
goto out_err;
}
if (u->pe_name && *u->pe_name) {
pe = ip_vs_pe_getbyname(u->pe_name);
if (pe == NULL) {
pr_info("persistence engine module ip_vs_pe_%s "
"not found\n", u->pe_name);
ret = -ENOENT;
goto out_err;
}
}
#ifdef CONFIG_IP_VS_IPV6
if (u->af == AF_INET6 && (u->netmask < 1 || u->netmask > 128)) {
ret = -EINVAL;
goto out_err;
}
#endif
svc = kzalloc(sizeof(struct ip_vs_service), GFP_KERNEL);
if (svc == NULL) {
IP_VS_DBG(1, "%s(): no memory\n", __func__);
ret = -ENOMEM;
goto out_err;
}
svc->stats.cpustats = alloc_percpu(struct ip_vs_cpu_stats);
if (!svc->stats.cpustats)
goto out_err;
/* I'm the first user of the service */
atomic_set(&svc->usecnt, 0);
atomic_set(&svc->refcnt, 0);
svc->af = u->af;
svc->protocol = u->protocol;
ip_vs_addr_copy(svc->af, &svc->addr, &u->addr);
svc->port = u->port;
svc->fwmark = u->fwmark;
svc->flags = u->flags;
svc->timeout = u->timeout * HZ;
svc->netmask = u->netmask;
svc->net = net;
INIT_LIST_HEAD(&svc->destinations);
rwlock_init(&svc->sched_lock);
spin_lock_init(&svc->stats.lock);
/* Bind the scheduler */
ret = ip_vs_bind_scheduler(svc, sched);
if (ret)
goto out_err;
sched = NULL;
/* Bind the ct retriever */
ip_vs_bind_pe(svc, pe);
pe = NULL;
/* Update the virtual service counters */
if (svc->port == FTPPORT)
atomic_inc(&ipvs->ftpsvc_counter);
else if (svc->port == 0)
atomic_inc(&ipvs->nullsvc_counter);
ip_vs_start_estimator(net, &svc->stats);
/* Count only IPv4 services for old get/setsockopt interface */
if (svc->af == AF_INET)
ipvs->num_services++;
/* Hash the service into the service table */
write_lock_bh(&__ip_vs_svc_lock);
ip_vs_svc_hash(svc);
write_unlock_bh(&__ip_vs_svc_lock);
*svc_p = svc;
/* Now there is a service - full throttle */
ipvs->enable = 1;
return 0;
out_err:
if (svc != NULL) {
ip_vs_unbind_scheduler(svc);
if (svc->inc) {
local_bh_disable();
ip_vs_app_inc_put(svc->inc);
local_bh_enable();
}
if (svc->stats.cpustats)
free_percpu(svc->stats.cpustats);
kfree(svc);
}
ip_vs_scheduler_put(sched);
ip_vs_pe_put(pe);
/* decrease the module use count */
ip_vs_use_count_dec();
return ret;
}
| 3,362 |
27,103 | 0 | static int handle_NPP_New(rpc_connection_t *connection)
{
D(bug("handle_NPP_New\n"));
rpc_connection_ref(connection);
uint32_t instance_id;
NPMIMEType plugin_type;
int32_t mode;
int argn_count, argv_count;
char **argn, **argv;
NPSavedData *saved;
int error = rpc_method_get_args(connection,
RPC_TYPE_UINT32, &instance_id,
RPC_TYPE_STRING, &plugin_type,
RPC_TYPE_INT32, &mode,
RPC_TYPE_ARRAY, RPC_TYPE_STRING, &argn_count, &argn,
RPC_TYPE_ARRAY, RPC_TYPE_STRING, &argv_count, &argv,
RPC_TYPE_NP_SAVED_DATA, &saved,
RPC_TYPE_INVALID);
if (error != RPC_ERROR_NO_ERROR) {
npw_perror("NPP_New() get args", error);
return error;
}
assert(argn_count == argv_count);
NPError ret = g_NPP_New(plugin_type, instance_id, mode, argn_count, argn, argv, saved);
if (plugin_type)
free(plugin_type);
if (argn) {
for (int i = 0; i < argn_count; i++)
free(argn[i]);
free(argn);
}
if (argv) {
for (int i = 0; i < argv_count; i++)
free(argv[i]);
free(argv);
}
if (saved) {
if (saved->buf)
NPN_MemFree(saved->buf);
NPN_MemFree(saved);
}
return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID);
}
| 3,363 |
169,163 | 0 | void RenderFrameHostImpl::OnForwardResourceTimingToParent(
const ResourceTimingInfo& resource_timing) {
if (!is_active())
return;
RenderFrameProxyHost* proxy =
frame_tree_node()->render_manager()->GetProxyToParent();
if (!proxy) {
bool is_current = IsCurrent();
bool has_parent = GetParent();
bool has_parent_ftn = frame_tree_node()->parent();
base::debug::Alias(&is_current);
base::debug::Alias(&has_parent);
base::debug::Alias(&has_parent_ftn);
bool parent_is_current = false;
bool parent_is_related_site_instance = false;
bool parent_is_top = false;
int32_t parent_site_instance_id = -1;
DEBUG_ALIAS_FOR_GURL(
parent_site_url,
has_parent ? GetParent()->GetSiteInstance()->GetSiteURL() : GURL());
if (has_parent) {
parent_is_current = GetParent()->IsCurrent();
parent_is_related_site_instance =
GetSiteInstance()->IsRelatedSiteInstance(
GetParent()->GetSiteInstance());
parent_is_top = !GetParent()->GetParent();
parent_site_instance_id = GetParent()->GetSiteInstance()->GetId();
}
base::debug::Alias(&parent_is_current);
base::debug::Alias(&parent_is_related_site_instance);
base::debug::Alias(&parent_is_top);
base::debug::Alias(&parent_site_instance_id);
bool parent_ftn_is_related_site_instance = false;
int32_t parent_ftn_site_instance_id = -1;
DEBUG_ALIAS_FOR_GURL(parent_ftn_site_url, frame_tree_node()->parent()
? frame_tree_node()
->parent()
->render_manager()
->current_frame_host()
->GetSiteInstance()
->GetSiteURL()
: GURL());
bool parent_ftn_has_speculative_rfh = false;
int32_t parent_ftn_speculative_site_instance_id = -1;
if (has_parent_ftn) {
parent_is_related_site_instance =
GetSiteInstance()->IsRelatedSiteInstance(frame_tree_node()
->parent()
->render_manager()
->current_frame_host()
->GetSiteInstance());
parent_ftn_has_speculative_rfh = frame_tree_node()
->parent()
->render_manager()
->speculative_frame_host();
if (parent_ftn_has_speculative_rfh) {
parent_ftn_speculative_site_instance_id = frame_tree_node()
->parent()
->render_manager()
->speculative_frame_host()
->GetSiteInstance()
->GetId();
}
}
base::debug::Alias(&parent_ftn_is_related_site_instance);
base::debug::Alias(&parent_ftn_site_instance_id);
base::debug::Alias(&parent_ftn_has_speculative_rfh);
base::debug::Alias(&parent_ftn_speculative_site_instance_id);
bool is_speculative =
frame_tree_node()->render_manager()->speculative_frame_host() == this;
int32_t site_instance_id = GetSiteInstance()->GetId();
DEBUG_ALIAS_FOR_GURL(ftn_site_url, GetSiteInstance()->GetSiteURL());
base::debug::Alias(&is_speculative);
base::debug::Alias(&site_instance_id);
bool ftn_has_speculative_rfh =
frame_tree_node()->render_manager()->speculative_frame_host();
int32_t speculative_site_instance_id = -1;
if (ftn_has_speculative_rfh) {
speculative_site_instance_id = frame_tree_node()
->render_manager()
->speculative_frame_host()
->GetSiteInstance()
->GetId();
}
base::debug::Alias(&ftn_has_speculative_rfh);
base::debug::Alias(&speculative_site_instance_id);
bool rvh_is_active = render_view_host()->is_active();
bool rvh_is_live = render_view_host()->IsRenderViewLive();
base::debug::Alias(&rvh_is_active);
base::debug::Alias(&rvh_is_live);
bool is_root = frame_tree_node()->frame_tree()->root() == frame_tree_node();
base::debug::Alias(&is_root);
bool root_rvh_is_active = frame_tree_node()
->frame_tree()
->root()
->current_frame_host()
->render_view_host()
->is_active();
bool root_rvh_is_live = frame_tree_node()
->frame_tree()
->root()
->current_frame_host()
->render_view_host()
->IsRenderViewLive();
bool root_rvh_is_waiting_for_close_ack = frame_tree_node()
->frame_tree()
->root()
->current_frame_host()
->render_view_host()
->is_waiting_for_close_ack();
base::debug::Alias(&root_rvh_is_active);
base::debug::Alias(&root_rvh_is_live);
base::debug::Alias(&root_rvh_is_waiting_for_close_ack);
bad_message::ReceivedBadMessage(GetProcess(),
bad_message::RFH_NO_PROXY_TO_PARENT);
return;
}
proxy->Send(new FrameMsg_ForwardResourceTimingToParent(proxy->GetRoutingID(),
resource_timing));
}
| 3,364 |
74,587 | 0 | static void __exit ovl_exit(void)
{
unregister_filesystem(&ovl_fs_type);
}
| 3,365 |
142,287 | 0 | ChromePasswordManagerClient::GetMetricsRecorder() {
if (!metrics_recorder_) {
metrics_recorder_.emplace(GetUkmSourceId(), GetMainFrameURL());
}
return base::OptionalOrNullptr(metrics_recorder_);
}
| 3,366 |
58,982 | 0 | do_core_note(struct magic_set *ms, unsigned char *nbuf, uint32_t type,
int swap, uint32_t namesz, uint32_t descsz,
size_t noff, size_t doff, int *flags, size_t size, int clazz)
{
#ifdef ELFCORE
int os_style = -1;
/*
* Sigh. The 2.0.36 kernel in Debian 2.1, at
* least, doesn't correctly implement name
* sections, in core dumps, as specified by
* the "Program Linking" section of "UNIX(R) System
* V Release 4 Programmer's Guide: ANSI C and
* Programming Support Tools", because my copy
* clearly says "The first 'namesz' bytes in 'name'
* contain a *null-terminated* [emphasis mine]
* character representation of the entry's owner
* or originator", but the 2.0.36 kernel code
* doesn't include the terminating null in the
* name....
*/
if ((namesz == 4 && strncmp((char *)&nbuf[noff], "CORE", 4) == 0) ||
(namesz == 5 && strcmp((char *)&nbuf[noff], "CORE") == 0)) {
os_style = OS_STYLE_SVR4;
}
if ((namesz == 8 && strcmp((char *)&nbuf[noff], "FreeBSD") == 0)) {
os_style = OS_STYLE_FREEBSD;
}
if ((namesz >= 11 && strncmp((char *)&nbuf[noff], "NetBSD-CORE", 11)
== 0)) {
os_style = OS_STYLE_NETBSD;
}
if (os_style != -1 && (*flags & FLAGS_DID_CORE_STYLE) == 0) {
if (file_printf(ms, ", %s-style", os_style_names[os_style])
== -1)
return 1;
*flags |= FLAGS_DID_CORE_STYLE;
*flags |= os_style;
}
switch (os_style) {
case OS_STYLE_NETBSD:
if (type == NT_NETBSD_CORE_PROCINFO) {
char sbuf[512];
struct NetBSD_elfcore_procinfo pi;
memset(&pi, 0, sizeof(pi));
memcpy(&pi, nbuf + doff, descsz);
if (file_printf(ms, ", from '%.31s', pid=%u, uid=%u, "
"gid=%u, nlwps=%u, lwp=%u (signal %u/code %u)",
file_printable(sbuf, sizeof(sbuf),
CAST(char *, pi.cpi_name)),
elf_getu32(swap, pi.cpi_pid),
elf_getu32(swap, pi.cpi_euid),
elf_getu32(swap, pi.cpi_egid),
elf_getu32(swap, pi.cpi_nlwps),
elf_getu32(swap, pi.cpi_siglwp),
elf_getu32(swap, pi.cpi_signo),
elf_getu32(swap, pi.cpi_sigcode)) == -1)
return 1;
*flags |= FLAGS_DID_CORE;
return 1;
}
break;
default:
if (type == NT_PRPSINFO && *flags & FLAGS_IS_CORE) {
size_t i, j;
unsigned char c;
/*
* Extract the program name. We assume
* it to be 16 characters (that's what it
* is in SunOS 5.x and Linux).
*
* Unfortunately, it's at a different offset
* in various OSes, so try multiple offsets.
* If the characters aren't all printable,
* reject it.
*/
for (i = 0; i < NOFFSETS; i++) {
unsigned char *cname, *cp;
size_t reloffset = prpsoffsets(i);
size_t noffset = doff + reloffset;
size_t k;
for (j = 0; j < 16; j++, noffset++,
reloffset++) {
/*
* Make sure we're not past
* the end of the buffer; if
* we are, just give up.
*/
if (noffset >= size)
goto tryanother;
/*
* Make sure we're not past
* the end of the contents;
* if we are, this obviously
* isn't the right offset.
*/
if (reloffset >= descsz)
goto tryanother;
c = nbuf[noffset];
if (c == '\0') {
/*
* A '\0' at the
* beginning is
* obviously wrong.
* Any other '\0'
* means we're done.
*/
if (j == 0)
goto tryanother;
else
break;
} else {
/*
* A nonprintable
* character is also
* wrong.
*/
if (!isprint(c) || isquote(c))
goto tryanother;
}
}
/*
* Well, that worked.
*/
/*
* Try next offsets, in case this match is
* in the middle of a string.
*/
for (k = i + 1 ; k < NOFFSETS; k++) {
size_t no;
int adjust = 1;
if (prpsoffsets(k) >= prpsoffsets(i))
continue;
for (no = doff + prpsoffsets(k);
no < doff + prpsoffsets(i); no++)
adjust = adjust
&& isprint(nbuf[no]);
if (adjust)
i = k;
}
cname = (unsigned char *)
&nbuf[doff + prpsoffsets(i)];
for (cp = cname; *cp && isprint(*cp); cp++)
continue;
/*
* Linux apparently appends a space at the end
* of the command line: remove it.
*/
while (cp > cname && isspace(cp[-1]))
cp--;
if (file_printf(ms, ", from '%.*s'",
(int)(cp - cname), cname) == -1)
return 1;
*flags |= FLAGS_DID_CORE;
return 1;
tryanother:
;
}
}
break;
}
#endif
return 0;
}
| 3,367 |
136,058 | 0 | void ExtensionWebContentsObserver::OnRequest(
content::RenderFrameHost* render_frame_host,
const ExtensionHostMsg_Request_Params& params) {
dispatcher_.Dispatch(params, render_frame_host);
}
| 3,368 |
180,701 | 1 | kadm5_modify_principal(void *server_handle,
kadm5_principal_ent_t entry, long mask)
{
int ret, ret2, i;
kadm5_policy_ent_rec pol;
krb5_boolean have_pol = FALSE;
krb5_db_entry *kdb;
krb5_tl_data *tl_data_orig;
osa_princ_ent_rec adb;
kadm5_server_handle_t handle = server_handle;
CHECK_HANDLE(server_handle);
krb5_clear_error_message(handle->context);
if((mask & KADM5_PRINCIPAL) || (mask & KADM5_LAST_PWD_CHANGE) ||
(mask & KADM5_MOD_TIME) || (mask & KADM5_MOD_NAME) ||
(mask & KADM5_MKVNO) || (mask & KADM5_AUX_ATTRIBUTES) ||
(mask & KADM5_KEY_DATA) || (mask & KADM5_LAST_SUCCESS) ||
(mask & KADM5_LAST_FAILED))
return KADM5_BAD_MASK;
if((mask & ~ALL_PRINC_MASK))
return KADM5_BAD_MASK;
if((mask & KADM5_POLICY) && (mask & KADM5_POLICY_CLR))
return KADM5_BAD_MASK;
if(entry == (kadm5_principal_ent_t) NULL)
return EINVAL;
if (mask & KADM5_TL_DATA) {
tl_data_orig = entry->tl_data;
while (tl_data_orig) {
if (tl_data_orig->tl_data_type < 256)
return KADM5_BAD_TL_TYPE;
tl_data_orig = tl_data_orig->tl_data_next;
}
}
ret = kdb_get_entry(handle, entry->principal, &kdb, &adb);
if (ret)
return(ret);
/*
* This is pretty much the same as create ...
*/
if ((mask & KADM5_POLICY)) {
ret = get_policy(handle, entry->policy, &pol, &have_pol);
if (ret)
goto done;
/* set us up to use the new policy */
adb.aux_attributes |= KADM5_POLICY;
if (adb.policy)
free(adb.policy);
adb.policy = strdup(entry->policy);
}
if (have_pol) {
/* set pw_max_life based on new policy */
if (pol.pw_max_life) {
ret = krb5_dbe_lookup_last_pwd_change(handle->context, kdb,
&(kdb->pw_expiration));
if (ret)
goto done;
kdb->pw_expiration += pol.pw_max_life;
} else {
kdb->pw_expiration = 0;
}
}
if ((mask & KADM5_POLICY_CLR) && (adb.aux_attributes & KADM5_POLICY)) {
free(adb.policy);
adb.policy = NULL;
adb.aux_attributes &= ~KADM5_POLICY;
kdb->pw_expiration = 0;
}
if ((mask & KADM5_ATTRIBUTES))
kdb->attributes = entry->attributes;
if ((mask & KADM5_MAX_LIFE))
kdb->max_life = entry->max_life;
if ((mask & KADM5_PRINC_EXPIRE_TIME))
kdb->expiration = entry->princ_expire_time;
if (mask & KADM5_PW_EXPIRATION)
kdb->pw_expiration = entry->pw_expiration;
if (mask & KADM5_MAX_RLIFE)
kdb->max_renewable_life = entry->max_renewable_life;
if((mask & KADM5_KVNO)) {
for (i = 0; i < kdb->n_key_data; i++)
kdb->key_data[i].key_data_kvno = entry->kvno;
}
if (mask & KADM5_TL_DATA) {
krb5_tl_data *tl;
/* may have to change the version number of the API. Updates the list with the given tl_data rather than over-writting */
for (tl = entry->tl_data; tl;
tl = tl->tl_data_next)
{
ret = krb5_dbe_update_tl_data(handle->context, kdb, tl);
if( ret )
{
goto done;
}
}
}
/*
* Setting entry->fail_auth_count to 0 can be used to manually unlock
* an account. It is not possible to set fail_auth_count to any other
* value using kadmin.
*/
if (mask & KADM5_FAIL_AUTH_COUNT) {
if (entry->fail_auth_count != 0) {
ret = KADM5_BAD_SERVER_PARAMS;
goto done;
}
kdb->fail_auth_count = 0;
}
/* let the mask propagate to the database provider */
kdb->mask = mask;
ret = k5_kadm5_hook_modify(handle->context, handle->hook_handles,
KADM5_HOOK_STAGE_PRECOMMIT, entry, mask);
if (ret)
goto done;
ret = kdb_put_entry(handle, kdb, &adb);
if (ret) goto done;
(void) k5_kadm5_hook_modify(handle->context, handle->hook_handles,
KADM5_HOOK_STAGE_POSTCOMMIT, entry, mask);
ret = KADM5_OK;
done:
if (have_pol) {
ret2 = kadm5_free_policy_ent(handle->lhandle, &pol);
ret = ret ? ret : ret2;
}
kdb_free_entry(handle, kdb, &adb);
return ret;
}
| 3,369 |
108,158 | 0 | GLsizei offset() const {
return offset_;
}
| 3,370 |
173,718 | 0 | SampleTable::~SampleTable() {
delete[] mSampleToChunkEntries;
mSampleToChunkEntries = NULL;
delete[] mSyncSamples;
mSyncSamples = NULL;
delete mCompositionDeltaLookup;
mCompositionDeltaLookup = NULL;
delete[] mCompositionTimeDeltaEntries;
mCompositionTimeDeltaEntries = NULL;
delete[] mSampleTimeEntries;
mSampleTimeEntries = NULL;
delete mSampleIterator;
mSampleIterator = NULL;
}
| 3,371 |
92,827 | 0 | Bool revert_cache_file(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
{
const char *url;
char *sep;
GF_Config *cached;
if (strncmp(item_name, "gpac_cache_", 11)) return GF_FALSE;
cached = gf_cfg_new(NULL, item_path);
url = gf_cfg_get_key(cached, "cache", "url");
if (url) url = strstr(url, "://");
if (url) {
u32 i, len, dir_len=0, k=0;
char *dst_name;
sep = strstr(item_path, "gpac_cache_");
if (sep) {
sep[0] = 0;
dir_len = (u32) strlen(item_path);
sep[0] = 'g';
}
url+=3;
len = (u32) strlen(url);
dst_name = gf_malloc(len+dir_len+1);
memset(dst_name, 0, len+dir_len+1);
strncpy(dst_name, item_path, dir_len);
k=dir_len;
for (i=0; i<len; i++) {
dst_name[k] = url[i];
if (dst_name[k]==':') dst_name[k]='_';
else if (dst_name[k]=='/') {
if (!gf_dir_exists(dst_name))
gf_mkdir(dst_name);
}
k++;
}
sep = strrchr(item_path, '.');
if (sep) {
sep[0]=0;
if (gf_file_exists(item_path)) {
gf_move_file(item_path, dst_name);
}
sep[0]='.';
}
gf_free(dst_name);
}
gf_cfg_del(cached);
gf_delete_file(item_path);
return GF_FALSE;
}
| 3,372 |
67,472 | 0 | int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
const unsigned char *file_name, u32 cookie)
{
struct hlist_node *inode_node = NULL, *vfsmount_node = NULL;
struct fsnotify_mark *inode_mark = NULL, *vfsmount_mark = NULL;
struct fsnotify_group *inode_group, *vfsmount_group;
struct fsnotify_mark_connector *inode_conn, *vfsmount_conn;
struct fsnotify_iter_info iter_info;
struct mount *mnt;
int ret = 0;
/* global tests shouldn't care about events on child only the specific event */
__u32 test_mask = (mask & ~FS_EVENT_ON_CHILD);
if (data_is == FSNOTIFY_EVENT_PATH)
mnt = real_mount(((const struct path *)data)->mnt);
else
mnt = NULL;
/*
* Optimization: srcu_read_lock() has a memory barrier which can
* be expensive. It protects walking the *_fsnotify_marks lists.
* However, if we do not walk the lists, we do not have to do
* SRCU because we have no references to any objects and do not
* need SRCU to keep them "alive".
*/
if (!to_tell->i_fsnotify_marks &&
(!mnt || !mnt->mnt_fsnotify_marks))
return 0;
/*
* if this is a modify event we may need to clear the ignored masks
* otherwise return if neither the inode nor the vfsmount care about
* this type of event.
*/
if (!(mask & FS_MODIFY) &&
!(test_mask & to_tell->i_fsnotify_mask) &&
!(mnt && test_mask & mnt->mnt_fsnotify_mask))
return 0;
iter_info.srcu_idx = srcu_read_lock(&fsnotify_mark_srcu);
if ((mask & FS_MODIFY) ||
(test_mask & to_tell->i_fsnotify_mask)) {
inode_conn = srcu_dereference(to_tell->i_fsnotify_marks,
&fsnotify_mark_srcu);
if (inode_conn)
inode_node = srcu_dereference(inode_conn->list.first,
&fsnotify_mark_srcu);
}
if (mnt && ((mask & FS_MODIFY) ||
(test_mask & mnt->mnt_fsnotify_mask))) {
inode_conn = srcu_dereference(to_tell->i_fsnotify_marks,
&fsnotify_mark_srcu);
if (inode_conn)
inode_node = srcu_dereference(inode_conn->list.first,
&fsnotify_mark_srcu);
vfsmount_conn = srcu_dereference(mnt->mnt_fsnotify_marks,
&fsnotify_mark_srcu);
if (vfsmount_conn)
vfsmount_node = srcu_dereference(
vfsmount_conn->list.first,
&fsnotify_mark_srcu);
}
/*
* We need to merge inode & vfsmount mark lists so that inode mark
* ignore masks are properly reflected for mount mark notifications.
* That's why this traversal is so complicated...
*/
while (inode_node || vfsmount_node) {
inode_group = NULL;
inode_mark = NULL;
vfsmount_group = NULL;
vfsmount_mark = NULL;
if (inode_node) {
inode_mark = hlist_entry(srcu_dereference(inode_node, &fsnotify_mark_srcu),
struct fsnotify_mark, obj_list);
inode_group = inode_mark->group;
}
if (vfsmount_node) {
vfsmount_mark = hlist_entry(srcu_dereference(vfsmount_node, &fsnotify_mark_srcu),
struct fsnotify_mark, obj_list);
vfsmount_group = vfsmount_mark->group;
}
if (inode_group && vfsmount_group) {
int cmp = fsnotify_compare_groups(inode_group,
vfsmount_group);
if (cmp > 0) {
inode_group = NULL;
inode_mark = NULL;
} else if (cmp < 0) {
vfsmount_group = NULL;
vfsmount_mark = NULL;
}
}
iter_info.inode_mark = inode_mark;
iter_info.vfsmount_mark = vfsmount_mark;
ret = send_to_group(to_tell, inode_mark, vfsmount_mark, mask,
data, data_is, cookie, file_name,
&iter_info);
if (ret && (mask & ALL_FSNOTIFY_PERM_EVENTS))
goto out;
if (inode_group)
inode_node = srcu_dereference(inode_node->next,
&fsnotify_mark_srcu);
if (vfsmount_group)
vfsmount_node = srcu_dereference(vfsmount_node->next,
&fsnotify_mark_srcu);
}
ret = 0;
out:
srcu_read_unlock(&fsnotify_mark_srcu, iter_info.srcu_idx);
return ret;
}
| 3,373 |
59,619 | 0 | saxParseTest(const char *filename, const char *result,
const char *err ATTRIBUTE_UNUSED,
int options) {
int ret;
char *temp;
nb_tests++;
temp = resultFilename(filename, "", ".res");
if (temp == NULL) {
fprintf(stderr, "out of memory\n");
fatalError();
}
SAXdebug = fopen(temp, "wb");
if (SAXdebug == NULL) {
fprintf(stderr, "Failed to write to %s\n", temp);
free(temp);
return(-1);
}
/* for SAX we really want the callbacks though the context handlers */
xmlSetStructuredErrorFunc(NULL, NULL);
xmlSetGenericErrorFunc(NULL, testErrorHandler);
#ifdef LIBXML_HTML_ENABLED
if (options & XML_PARSE_HTML) {
htmlSAXParseFile(filename, NULL, emptySAXHandler, NULL);
ret = 0;
} else
#endif
ret = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
if (ret == XML_WAR_UNDECLARED_ENTITY) {
fprintf(SAXdebug, "xmlSAXUserParseFile returned error %d\n", ret);
ret = 0;
}
if (ret != 0) {
fprintf(stderr, "Failed to parse %s\n", filename);
ret = 1;
goto done;
}
#ifdef LIBXML_HTML_ENABLED
if (options & XML_PARSE_HTML) {
htmlSAXParseFile(filename, NULL, debugHTMLSAXHandler, NULL);
ret = 0;
} else
#endif
if (options & XML_PARSE_SAX1) {
ret = xmlSAXUserParseFile(debugSAXHandler, NULL, filename);
} else {
ret = xmlSAXUserParseFile(debugSAX2Handler, NULL, filename);
}
if (ret == XML_WAR_UNDECLARED_ENTITY) {
fprintf(SAXdebug, "xmlSAXUserParseFile returned error %d\n", ret);
ret = 0;
}
fclose(SAXdebug);
if (compareFiles(temp, result)) {
fprintf(stderr, "Got a difference for %s\n", filename);
ret = 1;
}
done:
if (temp != NULL) {
unlink(temp);
free(temp);
}
/* switch back to structured error handling */
xmlSetGenericErrorFunc(NULL, NULL);
xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler);
return(ret);
}
| 3,374 |
175,951 | 0 | void smp_send_enc_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
tBTM_LE_LENC_KEYS le_key;
SMP_TRACE_DEBUG("%s: p_cb->loc_enc_size = %d", __func__, p_cb->loc_enc_size);
smp_update_key_mask(p_cb, SMP_SEC_KEY_TYPE_ENC, false);
smp_send_cmd(SMP_OPCODE_ENCRYPT_INFO, p_cb);
smp_send_cmd(SMP_OPCODE_MASTER_ID, p_cb);
/* save the DIV and key size information when acting as slave device */
memcpy(le_key.ltk, p_cb->ltk, BT_OCTET16_LEN);
le_key.div = p_cb->div;
le_key.key_size = p_cb->loc_enc_size;
le_key.sec_level = p_cb->sec_level;
if ((p_cb->peer_auth_req & SMP_AUTH_BOND) &&
(p_cb->loc_auth_req & SMP_AUTH_BOND))
btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LENC,
(tBTM_LE_KEY_VALUE*)&le_key, true);
SMP_TRACE_WARNING("%s", __func__);
smp_key_distribution(p_cb, NULL);
}
| 3,375 |
60,584 | 0 | static int snd_seq_ioctl_create_queue(struct snd_seq_client *client, void *arg)
{
struct snd_seq_queue_info *info = arg;
struct snd_seq_queue *q;
q = snd_seq_queue_alloc(client->number, info->locked, info->flags);
if (IS_ERR(q))
return PTR_ERR(q);
info->queue = q->queue;
info->locked = q->locked;
info->owner = q->owner;
/* set queue name */
if (!info->name[0])
snprintf(info->name, sizeof(info->name), "Queue-%d", q->queue);
strlcpy(q->name, info->name, sizeof(q->name));
snd_use_lock_free(&q->use_lock);
return 0;
}
| 3,376 |
152,908 | 0 | DevToolsWindow* DevToolsWindow::Create(
Profile* profile,
const GURL& frontend_url,
content::WebContents* inspected_web_contents,
bool shared_worker_frontend,
bool v8_only_frontend,
const std::string& remote_frontend,
bool can_dock,
const std::string& settings) {
if (profile->GetPrefs()->GetBoolean(prefs::kDevToolsDisabled) ||
base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
return nullptr;
if (inspected_web_contents) {
Browser* browser = NULL;
int tab;
if (!FindInspectedBrowserAndTabIndex(inspected_web_contents,
&browser, &tab) ||
browser->is_type_popup()) {
can_dock = false;
}
}
GURL url(GetDevToolsURL(profile, frontend_url,
shared_worker_frontend,
v8_only_frontend,
remote_frontend,
can_dock));
std::unique_ptr<WebContents> main_web_contents(
WebContents::Create(WebContents::CreateParams(profile)));
main_web_contents->GetController().LoadURL(
DecorateFrontendURL(url), content::Referrer(),
ui::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string());
DevToolsUIBindings* bindings =
DevToolsUIBindings::ForWebContents(main_web_contents.get());
if (!bindings)
return nullptr;
if (!settings.empty())
SetPreferencesFromJson(profile, settings);
return new DevToolsWindow(profile, main_web_contents.release(), bindings,
inspected_web_contents, can_dock);
}
| 3,377 |
181,774 | 1 | static Image *ReadSCREENSHOTImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
Image
*image;
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=(Image *) NULL;
#if defined(MAGICKCORE_WINGDI32_DELEGATE)
{
BITMAPINFO
bmi;
DISPLAY_DEVICE
device;
HBITMAP
bitmap,
bitmapOld;
HDC
bitmapDC,
hDC;
Image
*screen;
int
i;
register PixelPacket
*q;
register ssize_t
x;
RGBTRIPLE
*p;
ssize_t
y;
assert(image_info != (const ImageInfo *) NULL);
i=0;
device.cb = sizeof(device);
image=(Image *) NULL;
while(EnumDisplayDevices(NULL,i,&device,0) && ++i)
{
if ((device.StateFlags & DISPLAY_DEVICE_ACTIVE) != DISPLAY_DEVICE_ACTIVE)
continue;
hDC=CreateDC(device.DeviceName,device.DeviceName,NULL,NULL);
if (hDC == (HDC) NULL)
ThrowReaderException(CoderError,"UnableToCreateDC");
screen=AcquireImage(image_info);
screen->columns=(size_t) GetDeviceCaps(hDC,HORZRES);
screen->rows=(size_t) GetDeviceCaps(hDC,VERTRES);
screen->storage_class=DirectClass;
if (image == (Image *) NULL)
image=screen;
else
AppendImageToList(&image,screen);
bitmapDC=CreateCompatibleDC(hDC);
if (bitmapDC == (HDC) NULL)
{
DeleteDC(hDC);
ThrowReaderException(CoderError,"UnableToCreateDC");
}
(void) ResetMagickMemory(&bmi,0,sizeof(BITMAPINFO));
bmi.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth=(LONG) screen->columns;
bmi.bmiHeader.biHeight=(-1)*(LONG) screen->rows;
bmi.bmiHeader.biPlanes=1;
bmi.bmiHeader.biBitCount=24;
bmi.bmiHeader.biCompression=BI_RGB;
bitmap=CreateDIBSection(hDC,&bmi,DIB_RGB_COLORS,(void **) &p,NULL,0);
if (bitmap == (HBITMAP) NULL)
{
DeleteDC(hDC);
DeleteDC(bitmapDC);
ThrowReaderException(CoderError,"UnableToCreateBitmap");
}
bitmapOld=(HBITMAP) SelectObject(bitmapDC,bitmap);
if (bitmapOld == (HBITMAP) NULL)
{
DeleteDC(hDC);
DeleteDC(bitmapDC);
DeleteObject(bitmap);
ThrowReaderException(CoderError,"UnableToCreateBitmap");
}
BitBlt(bitmapDC,0,0,(int) screen->columns,(int) screen->rows,hDC,0,0,
SRCCOPY);
(void) SelectObject(bitmapDC,bitmapOld);
for (y=0; y < (ssize_t) screen->rows; y++)
{
q=QueueAuthenticPixels(screen,0,y,screen->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) screen->columns; x++)
{
SetPixelRed(q,ScaleCharToQuantum(p->rgbtRed));
SetPixelGreen(q,ScaleCharToQuantum(p->rgbtGreen));
SetPixelBlue(q,ScaleCharToQuantum(p->rgbtBlue));
SetPixelOpacity(q,OpaqueOpacity);
p++;
q++;
}
if (SyncAuthenticPixels(screen,exception) == MagickFalse)
break;
}
DeleteDC(hDC);
DeleteDC(bitmapDC);
DeleteObject(bitmap);
}
}
#elif defined(MAGICKCORE_X11_DELEGATE)
{
const char
*option;
XImportInfo
ximage_info;
(void) exception;
XGetImportInfo(&ximage_info);
option=GetImageOption(image_info,"x:screen");
if (option != (const char *) NULL)
ximage_info.screen=IsMagickTrue(option);
option=GetImageOption(image_info,"x:silent");
if (option != (const char *) NULL)
ximage_info.silent=IsMagickTrue(option);
image=XImportImage(image_info,&ximage_info);
}
#endif
return(image);
}
| 3,378 |
28,134 | 0 | void ff_put_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
{
put_pixels8_xy2_8_c(dst, src, stride, 8);
}
| 3,379 |
125,071 | 0 | static SiteInstanceImpl* CreateSiteInstance(
BrowserContext* browser_context,
RenderProcessHostFactory* factory,
const GURL& url) {
SiteInstanceImpl* instance =
reinterpret_cast<SiteInstanceImpl*>(
SiteInstance::CreateForURL(browser_context, url));
instance->set_render_process_host_factory(factory);
return instance;
}
| 3,380 |
53,215 | 0 | static int proc_claim_port(struct usb_dev_state *ps, void __user *arg)
{
unsigned portnum;
int rc;
if (get_user(portnum, (unsigned __user *) arg))
return -EFAULT;
rc = usb_hub_claim_port(ps->dev, portnum, ps);
if (rc == 0)
snoop(&ps->dev->dev, "port %d claimed by process %d: %s\n",
portnum, task_pid_nr(current), current->comm);
return rc;
}
| 3,381 |
121,650 | 0 | static bool shouldEmitTabBeforeNode(Node* node)
{
RenderObject* r = node->renderer();
if (!r || !isTableCell(node))
return false;
RenderTableCell* rc = toRenderTableCell(r);
RenderTable* t = rc->table();
return t && (t->cellBefore(rc) || t->cellAbove(rc));
}
| 3,382 |
102,532 | 0 | RelayTruncate(const FilePath& path,
int64 length,
base::FileUtilProxy::StatusCallback* callback)
: RelayWithStatusCallback(callback),
path_(path),
length_(length) {
}
| 3,383 |
93,779 | 0 | virDomainCreateXML(virConnectPtr conn, const char *xmlDesc,
unsigned int flags)
{
VIR_DEBUG("conn=%p, xmlDesc=%s, flags=%x", conn, NULLSTR(xmlDesc), flags);
virResetLastError();
virCheckConnectReturn(conn, NULL);
virCheckNonNullArgGoto(xmlDesc, error);
virCheckReadOnlyGoto(conn->flags, error);
if (conn->driver->domainCreateXML) {
virDomainPtr ret;
ret = conn->driver->domainCreateXML(conn, xmlDesc, flags);
if (!ret)
goto error;
return ret;
}
virReportUnsupportedError();
error:
virDispatchError(conn);
return NULL;
}
| 3,384 |
19,615 | 0 | void revert_creds(const struct cred *old)
{
const struct cred *override = current->cred;
kdebug("revert_creds(%p{%d,%d})", old,
atomic_read(&old->usage),
read_cred_subscribers(old));
validate_creds(old);
validate_creds(override);
alter_cred_subscribers(old, 1);
rcu_assign_pointer(current->cred, old);
alter_cred_subscribers(override, -1);
put_cred(override);
}
| 3,385 |
144,946 | 0 | void RenderWidgetHostViewAura::OnDisplayRemoved(
const display::Display& old_display) {}
| 3,386 |
156,431 | 0 | void RenderFrameDevToolsAgentHost::ConnectWebContents(WebContents* wc) {
RenderFrameHostImpl* host =
static_cast<RenderFrameHostImpl*>(wc->GetMainFrame());
DCHECK(host);
SetFrameTreeNode(host->frame_tree_node());
UpdateFrameHost(host);
}
| 3,387 |
103,662 | 0 | void BrowserRenderProcessHost::ClearTransportDIBCache() {
STLDeleteContainerPairSecondPointers(
cached_dibs_.begin(), cached_dibs_.end());
cached_dibs_.clear();
}
| 3,388 |
124,681 | 0 | bool canCollapseMarginAfterWithLastChild() const { return m_canCollapseMarginAfterWithLastChild; }
| 3,389 |
119,883 | 0 | bool FrameLoader::closeURL()
{
history()->saveDocumentState();
if (m_frame->document())
m_frame->document()->dispatchUnloadEvents();
stopLoading();
m_frame->editor().clearUndoRedoOperations();
return true;
}
| 3,390 |
58,069 | 0 | static ssize_t cuse_write_iter(struct kiocb *kiocb, struct iov_iter *from)
{
struct fuse_io_priv io = { .async = 0, .file = kiocb->ki_filp };
loff_t pos = 0;
/*
* No locking or generic_write_checks(), the server is
* responsible for locking and sanity checks.
*/
return fuse_direct_io(&io, from, &pos,
FUSE_DIO_WRITE | FUSE_DIO_CUSE);
}
| 3,391 |
63,026 | 0 | static int vmx_check_nested_events(struct kvm_vcpu *vcpu, bool external_intr)
{
struct vcpu_vmx *vmx = to_vmx(vcpu);
unsigned long exit_qual;
if (kvm_event_needs_reinjection(vcpu))
return -EBUSY;
if (vcpu->arch.exception.pending &&
nested_vmx_check_exception(vcpu, &exit_qual)) {
if (vmx->nested.nested_run_pending)
return -EBUSY;
nested_vmx_inject_exception_vmexit(vcpu, exit_qual);
vcpu->arch.exception.pending = false;
return 0;
}
if (nested_cpu_has_preemption_timer(get_vmcs12(vcpu)) &&
vmx->nested.preemption_timer_expired) {
if (vmx->nested.nested_run_pending)
return -EBUSY;
nested_vmx_vmexit(vcpu, EXIT_REASON_PREEMPTION_TIMER, 0, 0);
return 0;
}
if (vcpu->arch.nmi_pending && nested_exit_on_nmi(vcpu)) {
if (vmx->nested.nested_run_pending)
return -EBUSY;
nested_vmx_vmexit(vcpu, EXIT_REASON_EXCEPTION_NMI,
NMI_VECTOR | INTR_TYPE_NMI_INTR |
INTR_INFO_VALID_MASK, 0);
/*
* The NMI-triggered VM exit counts as injection:
* clear this one and block further NMIs.
*/
vcpu->arch.nmi_pending = 0;
vmx_set_nmi_mask(vcpu, true);
return 0;
}
if ((kvm_cpu_has_interrupt(vcpu) || external_intr) &&
nested_exit_on_intr(vcpu)) {
if (vmx->nested.nested_run_pending)
return -EBUSY;
nested_vmx_vmexit(vcpu, EXIT_REASON_EXTERNAL_INTERRUPT, 0, 0);
return 0;
}
vmx_complete_nested_posted_interrupt(vcpu);
return 0;
}
| 3,392 |
101,934 | 0 | void MockPrinter::GetDefaultPrintSettings(PrintMsg_Print_Params* params) {
EXPECT_EQ(-1, document_cookie_);
document_cookie_ = CreateDocumentCookie();
params->Reset();
SetPrintParams(params);
}
| 3,393 |
78,615 | 0 | pgp_update_new_algo_attr(sc_card_t *card, sc_cardctl_openpgp_keygen_info_t *key_info)
{
struct pgp_priv_data *priv = DRVDATA(card);
pgp_blob_t *algo_blob;
unsigned int old_modulus_len; /* measured in bits */
unsigned int old_exponent_len;
const unsigned int tag = 0x00C0 | key_info->keytype;
u8 changed = 0;
int r = SC_SUCCESS;
LOG_FUNC_CALLED(card->ctx);
/* get old algorithm attributes */
r = pgp_seek_blob(card, priv->mf, (0x00C0 | key_info->keytype), &algo_blob);
LOG_TEST_RET(card->ctx, r, "Cannot get old algorithm attributes");
old_modulus_len = bebytes2ushort(algo_blob->data + 1); /* modulus length is coded in byte 2 & 3 */
sc_log(card->ctx,
"Old modulus length %d, new %"SC_FORMAT_LEN_SIZE_T"u.",
old_modulus_len, key_info->modulus_len);
old_exponent_len = bebytes2ushort(algo_blob->data + 3); /* exponent length is coded in byte 3 & 4 */
sc_log(card->ctx,
"Old exponent length %d, new %"SC_FORMAT_LEN_SIZE_T"u.",
old_exponent_len, key_info->exponent_len);
/* Modulus */
/* If passed modulus_len is zero, it means using old key size */
if (key_info->modulus_len == 0) {
sc_log(card->ctx, "Use old modulus length (%d).", old_modulus_len);
key_info->modulus_len = old_modulus_len;
}
/* To generate key with new key size */
else if (old_modulus_len != key_info->modulus_len) {
algo_blob->data[1] = (unsigned char)(key_info->modulus_len >> 8);
algo_blob->data[2] = (unsigned char)key_info->modulus_len;
changed = 1;
}
/* Exponent */
if (key_info->exponent_len == 0) {
sc_log(card->ctx, "Use old exponent length (%d).", old_exponent_len);
key_info->exponent_len = old_exponent_len;
}
else if (old_exponent_len != key_info->exponent_len) {
algo_blob->data[3] = (unsigned char)(key_info->exponent_len >> 8);
algo_blob->data[4] = (unsigned char)key_info->exponent_len;
changed = 1;
}
/* If the key to-be-generated has different size,
* set this new value for GENERATE ASYMMETRIC KEY PAIR to work */
if (changed) {
r = pgp_put_data(card, tag, algo_blob->data, 6);
/* Note: Don't use pgp_set_blob to set data, because it won't touch the real DO */
LOG_TEST_RET(card->ctx, r, "Cannot set new algorithm attributes");
}
LOG_FUNC_RETURN(card->ctx, r);
}
| 3,394 |
173,058 | 0 | gp_g16(Pixel *p, png_const_voidp pb)
{
png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
p->r = p->g = p->b = pp[0];
p->a = 65535;
}
| 3,395 |
299 | 0 | clamp_lab_icc(const fz_colorspace *cs, const float *src, float *dst)
{
dst[0] = (fz_clamp(src[0], 0, 100)) / 100.0f;
dst[1] = (fz_clamp(src[1], -128, 127) + 128.0f) / 256;
dst[2] = (fz_clamp(src[2], -128, 127) + 128.0f) / 256;
}
| 3,396 |
104,072 | 0 | void GLES2DecoderImpl::DoVertexAttrib4fv(GLuint index, const GLfloat* v) {
VertexAttribManager::VertexAttribInfo* info =
vertex_attrib_manager_.GetVertexAttribInfo(index);
if (!info) {
SetGLError(GL_INVALID_VALUE, "glVertexAttrib4fv: index out of range");
return;
}
VertexAttribManager::VertexAttribInfo::Vec4 value;
value.v[0] = v[0];
value.v[1] = v[1];
value.v[2] = v[2];
value.v[3] = v[3];
info->set_value(value);
glVertexAttrib4fv(index, v);
}
| 3,397 |
147,150 | 0 | void V8TestObject::ActivityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
RUNTIME_CALL_TIMER_SCOPE_DISABLED_BY_DEFAULT(info.GetIsolate(), "Blink_TestObject_activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute_Getter");
ScriptState* script_state = ScriptState::ForRelevantRealm(info);
V8PerContextData* context_data = script_state->PerContextData();
if (context_data && context_data->ActivityLogger()) {
context_data->ActivityLogger()->LogGetter("TestObject.activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute");
}
test_object_v8_internal::ActivityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetter(info);
}
| 3,398 |
168,433 | 0 | TestBrowserWindow::~TestBrowserWindow() {}
| 3,399 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.