Implementation of concurrent blocking queue for producer-consumer
Basic comments:
No point in functions that do nothing.
Also avoid void as definition for empty parameter list.
~condition_variable(void) {}

Why put a member that has no default constructor in the initializer list ( I can go either way)
concurrent_blocking_queue(size_t capacity) 
    : m_capacity(capacity), m_critical_section()

But you should be consistent and thus if you do it for one then you should do it for all members.
Design:
When you call full() and empty() from within other members you already have a lock. Yet you are calling a function that will add another level of locking. And locking is usually relatively expensive.
    m_queue_full.wait(lock, [&amp;]{ return !full(); });

    m_queue_empty.wait(lock, [&amp;]{ return !empty(); });

Thus I would change the above to call a private version of these function that do not use locks.
    // OLD STUFF
    m_queue_full.wait(lock, [&amp;]{ return !test_full(); });

    // OLD STUFF
    m_queue_empty.wait(lock, [&amp;]{ return !test_empty(); });

    bool full() const
    {
      framework::scoped_lock lock(m_critical_section);
      return test_full();
    }
    bool empty() const
    {
      framework::scoped_lock lock(m_critical_section);
      return test_empty();
    }

    private:
    bool test_full()  const {STUFF}
    bool test_empty() const {STUFF}