Beispiel #1
0
void release_test()
{
  sig_type sig;
  bs2::connection conn;
  {
    bs2::scoped_connection scoped(sig.connect(&myslot));
    BOOST_CHECK(scoped.connected());
    conn = scoped.release();
  }
  BOOST_CHECK(conn.connected());

  bs2::connection conn2;
  {
    bs2::scoped_connection scoped(conn);
    BOOST_CHECK(scoped.connected());
    conn = scoped.release();
    BOOST_CHECK(conn.connected());
    BOOST_CHECK(scoped.connected() == false);
    conn.disconnect();

    // earlier release shouldn't affect new connection
    conn2 = sig.connect(&myslot);
    scoped = conn2;
  }
  BOOST_CHECK(conn2.connected() == false);
}
void EXTDisjointTimerQuery::beginQueryEXT(GLenum target, WebGLTimerQueryEXT* query)
{
    WebGLExtensionScopedContext scoped(this);
    if (scoped.isLost())
        return;

    if (!query || query->isDeleted() || !query->validate(0, scoped.context())) {
        scoped.context()->webContext()->synthesizeGLError(GL_INVALID_OPERATION);
        return;
    }

    if (target != GL_TIME_ELAPSED_EXT) {
        scoped.context()->webContext()->synthesizeGLError(GL_INVALID_ENUM);
        return;
    }

    if (m_currentElapsedQuery.get()) {
        scoped.context()->webContext()->synthesizeGLError(GL_INVALID_OPERATION);
        return;
    }

    if (query->hasTarget() && query->target() != target) {
        scoped.context()->webContext()->synthesizeGLError(GL_INVALID_OPERATION);
        return;
    }

    scoped.context()->webContext()->beginQueryEXT(target, query->object());
    query->setTarget(target);
    m_currentElapsedQuery = query;
}
Beispiel #3
0
void HttpLoader::threadHttpRequest()
{
  try {
    base::ScopedValue<bool> scoped(m_done, false, true);

    LOG("Sending http request to %s...\n", m_url.c_str());

    std::string dir = base::join_path(base::get_temp_path(), PACKAGE);
    base::make_all_directories(dir);

    std::string fn = m_url;
    base::replace_string(fn, ":", "-");
    base::replace_string(fn, "/", "-");
    base::replace_string(fn, "?", "-");
    base::replace_string(fn, "&", "-");
    fn = base::join_path(dir, fn);

    std::ofstream output(FSTREAM_PATH(fn), std::ofstream::binary);
    net::HttpRequest http(m_url);
    net::HttpResponse response(&output);
    http.send(response);

    if (response.status() == 200)
      m_filename = fn;

    LOG("Response: %d\n", response.status());
  }
  catch (const std::exception& e) {
    LOG("Unexpected exception sending http request: '%s'\n", e.what());
  }
  catch (...) {
    LOG("Unexpected unknown exception sending http request\n");
  }
}
Beispiel #4
0
void WebGLDrawBuffers::drawBuffersWEBGL(const Vector<GLenum>& buffers)
{
    WebGLExtensionScopedContext scoped(this);
    if (scoped.isLost())
        return;
    GLsizei n = buffers.size();
    const GLenum* bufs = buffers.data();
    if (!scoped.context()->m_framebufferBinding) {
        if (n != 1) {
            scoped.context()->synthesizeGLError(GL_INVALID_VALUE, "drawBuffersWEBGL", "more than one buffer");
            return;
        }
        if (bufs[0] != GL_BACK && bufs[0] != GL_NONE) {
            scoped.context()->synthesizeGLError(GL_INVALID_OPERATION, "drawBuffersWEBGL", "BACK or NONE");
            return;
        }
        // Because the backbuffer is simulated on all current WebKit ports, we need to change BACK to COLOR_ATTACHMENT0.
        GLenum value = (bufs[0] == GL_BACK) ? GL_COLOR_ATTACHMENT0 : GL_NONE;
        scoped.context()->webContext()->drawBuffersEXT(1, &value);
        scoped.context()->setBackDrawBuffer(bufs[0]);
    } else {
        if (n > scoped.context()->maxDrawBuffers()) {
            scoped.context()->synthesizeGLError(GL_INVALID_VALUE, "drawBuffersWEBGL", "more than max draw buffers");
            return;
        }
        for (GLsizei i = 0; i < n; ++i) {
            if (bufs[i] != GL_NONE && bufs[i] != static_cast<GLenum>(GL_COLOR_ATTACHMENT0_EXT + i)) {
                scoped.context()->synthesizeGLError(GL_INVALID_OPERATION, "drawBuffersWEBGL", "COLOR_ATTACHMENTi_EXT or NONE");
                return;
            }
        }
        scoped.context()->m_framebufferBinding->drawBuffers(buffers);
    }
}
ScriptValue EXTDisjointTimerQuery::getQueryEXT(ScriptState* scriptState, GLenum target, GLenum pname)
{
    WebGLExtensionScopedContext scoped(this);
    if (scoped.isLost())
        return ScriptValue::createNull(scriptState);

    if (target == GL_TIMESTAMP_EXT || target == GL_TIME_ELAPSED_EXT) {
        switch (pname) {
        case GL_CURRENT_QUERY_EXT:
            if (GL_TIME_ELAPSED_EXT == target && m_currentElapsedQuery.get())
                return WebGLAny(scriptState, m_currentElapsedQuery.get());
            return ScriptValue::createNull(scriptState);
        case GL_QUERY_COUNTER_BITS_EXT: {
            GLint value = 0;
            scoped.context()->webContext()->getQueryivEXT(target, pname, &value);
            return WebGLAny(scriptState, value);
        }
        default:
            break;
        }
    }

    scoped.context()->webContext()->synthesizeGLError(GL_INVALID_ENUM);
    return ScriptValue::createNull(scriptState);
}
Beispiel #6
0
void Searcher::publishCharacters(const std::vector<Filesystem::AbsolutePath> & files){
    PaintownUtil::Thread::ScopedLock scoped(subscriptionLock);
    for (vector<Subscriber*>::iterator it = subscriptions.begin(); it != subscriptions.end(); it++){
        Subscriber * who = *it;
        who->receiveCharacters(files);
    }
}
Beispiel #7
0
    void FailPoint::setMode(Mode mode, ValType val, const BSONObj& extra) {
        /**
         * Outline:
         *
         * 1. Deactivates fail point to enter write-only mode
         * 2. Waits for all current readers of the fail point to finish
         * 3. Sets the new mode.
         */

        scoped_lock scoped(_modMutex);

        // Step 1
        disableFailPoint();

        // Step 2
        while (_fpInfo.load() != 0) {
            sleepmillis(50);
        }

        // Step 3
        uassert(16442, stream() << "mode not supported " << static_cast<int>(mode),
                mode >= off && mode < numModes);

        _mode = mode;
        _timesOrPeriod.store(val);

        _data = extra.copy();

        if (_mode != off) {
            enableFailPoint();
        }
    }
Beispiel #8
0
void FailPoint::setMode(Mode mode, ValType val, const BSONObj& extra) {
    /**
     * Outline:
     *
     * 1. Deactivates fail point to enter write-only mode
     * 2. Waits for all current readers of the fail point to finish
     * 3. Sets the new mode.
     */

    stdx::lock_guard<stdx::mutex> scoped(_modMutex);

    // Step 1
    disableFailPoint();

    // Step 2
    while (_fpInfo.load() != 0) {
        sleepmillis(50);
    }

    _mode = mode;
    _timesOrPeriod.store(val);

    _data = extra.copy();

    if (_mode != off) {
        enableFailPoint();
    }
}
ScriptValue EXTDisjointTimerQuery::getQueryObjectEXT(ScriptState* scriptState, WebGLTimerQueryEXT* query, GLenum pname)
{
    WebGLExtensionScopedContext scoped(this);
    if (scoped.isLost())
        return ScriptValue::createNull(scriptState);

    if (!query || query->isDeleted() || !query->validate(0, scoped.context()) || m_currentElapsedQuery == query) {
        scoped.context()->webContext()->synthesizeGLError(GL_INVALID_OPERATION);
        return ScriptValue::createNull(scriptState);
    }

    switch (pname) {
    case GL_QUERY_RESULT_EXT: {
        query->updateCachedResult(scoped.context()->webContext());
        return WebGLAny(scriptState, query->getQueryResult());
    }
    case GL_QUERY_RESULT_AVAILABLE_EXT: {
        query->updateCachedResult(scoped.context()->webContext());
        return WebGLAny(scriptState, query->isQueryResultAvailable());
    }
    default:
        scoped.context()->webContext()->synthesizeGLError(GL_INVALID_ENUM);
        break;
    }

    return ScriptValue::createNull(scriptState);
}
void EXTDisjointTimerQuery::queryCounterEXT(WebGLTimerQueryEXT* query, GLenum target)
{
    WebGLExtensionScopedContext scoped(this);
    if (scoped.isLost())
        return;

    if (!query || query->isDeleted() || !query->validate(0, scoped.context())) {
        scoped.context()->webContext()->synthesizeGLError(GL_INVALID_OPERATION);
        return;
    }

    if (target != GL_TIMESTAMP_EXT) {
        scoped.context()->webContext()->synthesizeGLError(GL_INVALID_ENUM);
        return;
    }

    if (query->hasTarget() && query->target() != target) {
        scoped.context()->webContext()->synthesizeGLError(GL_INVALID_OPERATION);
        return;
    }

    scoped.context()->webContext()->queryCounterEXT(query->object(), target);
    query->setTarget(target);
    query->resetCachedResult();
}
void EXTDisjointTimerQuery::queryCounterEXT(WebGLTimerQueryEXT* query, GLenum target)
{
    WebGLExtensionScopedContext scoped(this);
    if (scoped.isLost())
        return;

    if (!query || query->isDeleted() || !query->validate(0, scoped.context())) {
        scoped.context()->synthesizeGLError(GL_INVALID_OPERATION, "queryCounterEXT", "invalid query");
        return;
    }

    if (target != GL_TIMESTAMP_EXT) {
        scoped.context()->synthesizeGLError(GL_INVALID_ENUM, "queryCounterEXT", "invalid target");
        return;
    }

    if (query->hasTarget() && query->target() != target) {
        scoped.context()->synthesizeGLError(GL_INVALID_OPERATION, "queryCounterEXT", "target does not match query");
        return;
    }

    // Timestamps are disabled in WebGL due to lack of driver support on multiple platforms, so we don't actually perform a GL call
    query->setTarget(target);
    query->resetCachedResult();
}
Beispiel #12
0
void Statistic::finished(shared_ptr<Statistic::JobMeasurement>& job)
{
#ifdef Statistic_Activated
	avgLock.lock();
	uint32_t n;
	for(int c = 0; c < Component::Size; c++) {
		if (!job->stopped[c])
			continue;

		AvgMeasurement& m = componentAvgs[c];

		n = m.count[job->zoom];
		m.average[job->zoom] *= n/(float)(n + 1.0f);
		m.average[job->zoom] += job->getDuration(c).total_microseconds() / (float)(n + 1.0f);
		m.count[job->zoom]++;
	}
	avgLock.unlock();

	if (!config->has(opt::server::performance_log))
		return;

	boost::mutex::scoped_lock scoped(bufferLock);

	measurementsBuffer.push_back(job);
	if(measurementsBuffer.size() > 100)
	{
		writeToFile(config->get<string>(opt::server::performance_log).c_str());
		measurementsBuffer.clear();
	}
#endif
}
Beispiel #13
0
  /// called directly by dds_visitor::visit_structure() if -Wb,java
  void generate(UTL_ScopedName* name) {
    if (idl_global->is_dcps_type(name) == 0) {
      // no #pragma DCPS_DATA_TYPE, so nothing to generate
      return;
    }

    ACE_CString output_file = be_global->java_arg();
    if (output_file.length()) {
      be_global->impl_name_ = output_file;
    }
    be_global->add_include("idl2jni_jni.h", BE_GlobalData::STREAM_CPP);

    std::string type = scoped(name);

    std::string file, jniclass, jpackage;
    for (UTL_ScopedName* sn = name; sn;
        sn = static_cast<UTL_ScopedName*>(sn->tail())) {
      std::string tmp = sn->head()->get_string();
      if (tmp != "" && sn->tail()) {
        jpackage += tmp;
        file += tmp;
        ACE_OS::mkdir(file.c_str());
      }
      for (size_t i = tmp.find('_'); i < tmp.length();
          i = tmp.find('_', i + 1)) {
        tmp.insert(++i, 1, '1');
      }
      jniclass += tmp;
      if (jniclass != "" && sn->tail()) {
        jniclass += '_';
        jpackage += '.';
        file += '/';
      }
    }

    if (jpackage[jpackage.size() - 1] == '.') {
      jpackage.resize(jpackage.size() - 1);
    }

    std::string clazz = name->last_component()->get_string();
    file += clazz + "TypeSupportImpl.java";

    std::ofstream java(file.c_str());
    java << (jpackage.size() ? "package " : "") << jpackage
      << (jpackage.size() ? ";\n" :"") <<
      "public class " << clazz << "TypeSupportImpl extends _" << clazz
      << "TypeSupportTAOPeer {\n"
      "    public " << clazz << "TypeSupportImpl() {\n"
      "        super(_jni_init());\n"
      "    }\n"
      "    private static native long _jni_init();\n"
      "}\n";
    be_global->impl_ <<
      "extern \"C\" JNIEXPORT jlong JNICALL\n"
      "Java_" << jniclass << "TypeSupportImpl__1jni_1init(JNIEnv*, jclass) {\n"
      "  return reinterpret_cast<jlong>(static_cast<CORBA::Object_ptr>(new "
      << type << "TypeSupportImpl));\n"
      "}\n\n";
  }
void ANGLEInstancedArrays::drawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
{
    WebGLExtensionScopedContext scoped(this);
    if (scoped.isLost())
        return;

    scoped.context()->drawArraysInstancedANGLE(mode, first, count, primcount);
}
void ANGLEInstancedArrays::drawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, long long offset, GLsizei primcount)
{
    WebGLExtensionScopedContext scoped(this);
    if (scoped.isLost())
        return;

    scoped.context()->drawElementsInstancedANGLE(mode, count, type, offset, primcount);
}
Beispiel #16
0
void connect_from_non_main_thread()
{
    std::cout<<"main thread : "<<boost::this_thread::get_id()<<std::endl;

    boost::strict_scoped_thread<> scoped(boost::thread(
                                             boost::bind(&worker_thread2))
                                         );
}
void ANGLEInstancedArrays::vertexAttribDivisorANGLE(GLuint index, GLuint divisor)
{
    WebGLExtensionScopedContext scoped(this);
    if (scoped.isLost())
        return;

    scoped.context()->vertexAttribDivisorANGLE(index, divisor);
}
Beispiel #18
0
/* check for an in-memory copy of the parse. if it doesnt exist
 * then either load it from disk or parse it.
 * returns a new copy of the AST so you must delete it later.
 */
Util::ReferenceCount<Ast::AstParse> Parser::parse(const Filesystem::AbsolutePath & path){
    PaintownUtil::Thread::ScopedLock scoped(lock);
    if (cache[path] == NULL){
        cache[path] = loadFile(path);
    }

    return cache[path];
}
Beispiel #19
0
    BSONObj FailPoint::toBSON() const {
        BSONObjBuilder builder;

        scoped_lock scoped(_modMutex);
        builder.append("mode", _mode);
        builder.append("data", _data);

        return builder.obj();
    }
void EXTDisjointTimerQuery::deleteQueryEXT(WebGLTimerQueryEXT* query) {
  WebGLExtensionScopedContext scoped(this);
  if (!query || scoped.isLost())
    return;
  query->deleteObject(scoped.context()->contextGL());

  if (query == m_currentElapsedQuery)
    m_currentElapsedQuery.clear();
}
GLboolean EXTDisjointTimerQuery::isQueryEXT(WebGLTimerQueryEXT* query)
{
    WebGLExtensionScopedContext scoped(this);
    if (!query || scoped.isLost() || query->isDeleted() || !query->validate(0, scoped.context())) {
        return false;
    }

    return scoped.context()->webContext()->isQueryEXT(query->object());
}
Beispiel #22
0
BSONObj FailPoint::toBSON() const {
    BSONObjBuilder builder;

    stdx::lock_guard<stdx::mutex> scoped(_modMutex);
    builder.append("mode", _mode);
    builder.append("data", _data);

    return builder.obj();
}
WebGLTimerQueryEXT* EXTDisjointTimerQuery::createQueryEXT() {
  WebGLExtensionScopedContext scoped(this);
  if (scoped.isLost())
    return nullptr;

  WebGLTimerQueryEXT* o = WebGLTimerQueryEXT::create(scoped.context());
  scoped.context()->addContextObject(o);
  return o;
}
Beispiel #24
0
bool ts_generator::gen_union(AST_Union*, UTL_ScopedName* name,
  const std::vector<AST_UnionBranch*>&, AST_Type*, const char*)
{
  if (idl_global->is_dcps_type(name)) {
    std::cerr << "ERROR: union " << scoped(name) << " can not be used as a "
      "DCPS_DATA_TYPE (only structs can be Topic types)" << std::endl;
    return false;
  }
  return true;
}
Beispiel #25
0
void connect_by_qt()
{
   std::cout<<"main thread : "<<boost::this_thread::get_id()<<std::endl;

   runSomething obj;
   //obj.print_value(44);
   boost::strict_scoped_thread<> scoped(boost::thread(
                                            boost::bind(&worker_thread3, boost::ref(obj)))
                                        );
}
Beispiel #26
0
void InspectorOverlay::updateAllLifecyclePhases() {
  if (isEmpty())
    return;

  AutoReset<bool> scoped(&m_inLayout, true);
  if (m_needsUpdate) {
    m_needsUpdate = false;
    rebuildOverlayPage();
  }
  overlayMainFrame()->view()->updateAllLifecyclePhases();
}
Beispiel #27
0
String WebGLDebugShaders::getTranslatedShaderSource(WebGLShader* shader) {
  WebGLExtensionScopedContext scoped(this);
  if (scoped.isLost())
    return String();
  if (!scoped.context()->validateWebGLObject("getTranslatedShaderSource",
                                             shader))
    return "";
  GLStringQuery query(scoped.context()->contextGL());
  return query.Run<GLStringQuery::TranslatedShaderSourceANGLE>(
      shader->object());
}
Beispiel #28
0
void connect_from_main_thread()
{
    boost::signals2::signal<void()> signal;
    signal.connect(print_something);
    signal();

    std::cout<<"main thread : "<<boost::this_thread::get_id()<<std::endl;

    boost::strict_scoped_thread<> scoped(boost::thread(
                                             boost::bind(&worker_thread, boost::ref(signal)))
                                         );
}
    static STGMEDIUM* GetStorageForBytes(const char* data, size_t bytes)
    {
        HANDLE handle = GlobalAlloc(GPTR, static_cast<int>(bytes));
        base::win::ScopedHGlobal<char> scoped(handle);
        size_t allocated = static_cast<size_t>(GlobalSize(handle));
        memcpy(scoped.get(), data, allocated);

        STGMEDIUM* storage = new STGMEDIUM;
        storage->hGlobal = handle;
        storage->tymed = TYMED_HGLOBAL;
        storage->pUnkForRelease = NULL;
        return storage;
    }
Beispiel #30
0
std::wstring VNCServer::GetEditorName()
{
	//Increase usage while in method
	ScopedUse scoped(use);
	
	//If we got another editor
	if (this->editorId)
	{
		//Find it
		Clients::iterator it = clients.find(this->editorId);
		//If found
		if (it!=clients.end())
			//Set client view onlu
			return it->second->GetName();
	}
	//Empty
	return std::wstring();
}