Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(2968)

Unified Diff: base/synchronized.h

Issue 624713003: Keep only base/extractor.[cc|h]. (Closed) Base URL: https://chromium.googlesource.com/external/omaha.git@master
Patch Set: Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « base/string_unittest.cc ('k') | base/synchronized.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: base/synchronized.h
diff --git a/base/synchronized.h b/base/synchronized.h
deleted file mode 100644
index 20d7208bf0c2bff86e8100e654276930ef7183bb..0000000000000000000000000000000000000000
--- a/base/synchronized.h
+++ /dev/null
@@ -1,358 +0,0 @@
-// Copyright 2004-2010 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// ========================================================================
-//
-// Declares some classes and macros to encapsulate
-// the synchronization primitives.
-
-// TODO(omaha): remove dependency on atlstr
-
-#ifndef OMAHA_BASE_SYNCHRONIZED_H_
-#define OMAHA_BASE_SYNCHRONIZED_H_
-
-#include <windows.h>
-#include <atlstr.h>
-#include "base/basictypes.h"
-
-namespace omaha {
-
-// This macros are used to create a unique name
-// We need to go through two steps of expansion.
-// Macro kMakeName1 will expand to string + number
-// and macro kMakeName1 will put them together to create
-// the unique name.
-#define MAKE_NAME2(x, y) x##y
-#define MAKE_NAME1(x, y) MAKE_NAME2(x, y)
-#define MAKE_NAME(x) MAKE_NAME1(x, __COUNTER__)
-
-// Declare the interface in implement mutual
-// exclusion. For in process mutual exclusion
-// simple critical sections can be used. For
-// interprocess mutual exclusion some named
-// kernel mode object will have to be used.
-struct Lockable {
- virtual ~Lockable() {}
- virtual bool Lock() const = 0;
- virtual bool Unlock() const = 0;
-};
-
-// Scope based mutual exclusion. Locks
-// the object on construction and unlocks
-// during destruction. Very convinient to use
-// with the macros __mutexScope and __mutexBlock
-class AutoSync {
- bool first_time_;
- public:
- explicit AutoSync(const Lockable *pLock);
- explicit AutoSync(const Lockable &rLock);
- ~AutoSync();
- // this function is only needed to use with
- // the macro __mutexBlock
- bool FirstTime();
- private:
- const Lockable * lock_;
- DISALLOW_EVIL_CONSTRUCTORS(AutoSync);
-};
-
-// the usaage:
-// class A : public Lockable {
-//
-//
-//
-// void foo(){
-// __mutexScope(this);
-// ......
-// .......
-// everything is synchronized till the end of the
-// function or the time it returns (from any place)
-// } // end foo.
-//
-// void bar() {
-// ......
-// ...... do something here.
-// ......
-// __mutexBlock(this){
-// .... do some other stuff
-// ....
-// ....
-// } everything is synchronized till here
-//
-// }; // end class A
-
-//
-#define __mutexScope(lock) AutoSync MAKE_NAME(hiddenLock)(lock)
-#define __mutexBlock(lock) \
- for (AutoSync hiddenLock(lock); hiddenLock.FirstTime(); )
-
-// GLock stands for global lock.
-// Implementaion of Lockable to allow mutual exclusion
-// between different processes.
-// For in-process mutual exclusion use LLock - local lock
-class GLock : public Lockable {
- public:
- GLock();
- virtual ~GLock();
-
- // Create mutex returns the status of creation. Use ::GetLastError for
- // error information.
- bool InitializeWithSecAttr(const TCHAR* name,
- LPSECURITY_ATTRIBUTES lock_attributes);
-
- // Create mutex return the status of creation. Sets to default DACL.
- bool Initialize(const TCHAR* name);
-
- virtual bool Lock() const;
- virtual bool Lock(DWORD dwMilliseconds) const;
- virtual bool Unlock() const;
-
- private:
-#if defined(DEBUG) || defined(ASSERT_IN_RELEASE)
- CString name_;
-#endif
- mutable HANDLE mutex_;
- DISALLOW_EVIL_CONSTRUCTORS(GLock);
-};
-
-// FakeGLock looks like a GLock, but none of its methods do anything.
-// Only used with SharedMemoryPtr, in cases where locking is not required or
-// desired.
-class FakeGLock : public Lockable {
- public:
- FakeGLock() {}
- virtual ~FakeGLock() {}
- bool InitializeWithSecAttr(const TCHAR*, LPSECURITY_ATTRIBUTES) {
- return true;
- }
- bool Initialize(const TCHAR*) { return true; }
- virtual bool Lock() const { return true; }
- virtual bool Lock(DWORD) const { return true; }
- virtual bool Unlock() const { return true; }
-
- private:
- DISALLOW_EVIL_CONSTRUCTORS(FakeGLock);
-};
-
-// LLock stands for local lock.
-// means works only inside the process.
-// use GLock - global lock for inter-process
-// guarded access to data.
-class LLock : public Lockable {
- public:
- LLock();
- virtual ~LLock();
- virtual bool Lock() const;
- virtual bool Lock(DWORD wait_ms) const;
- virtual bool Unlock() const;
-
- // Returns the thread id of the owner or 0 if the lock is not owned.
- DWORD GetOwner() const;
- private:
- mutable CRITICAL_SECTION critical_section_;
- DISALLOW_EVIL_CONSTRUCTORS(LLock);
-};
-
-// A gate is a synchronization object used to either stop all
-// threads from proceeding through a point or to allow them all to proceed.
-class Gate {
- public:
- // In process gate.
- Gate();
-
- // Interprocess gate.
- explicit Gate(const TCHAR * event_name);
-
- ~Gate();
-
- // Open the gate.
- bool Open();
-
- // Close the gate.
- bool Close();
-
- // Wait to enter the gate.
- bool Wait(DWORD msec);
-
- // Conversion from the object to a HANDLE.
- operator HANDLE() const {return gate_;}
-
- // Returns S_OK, and sets selected_gate to zero based index of the gate that
- // was opened.
- // Returns E_FAIL if timeout occured or gate was abandoned.
- static HRESULT WaitAny(Gate const * const *gates,
- int num_gates,
- DWORD msec,
- int *selected_gate);
-
- // Returns S_OK if all gates were opened
- // Returns E_FAIL if timeout occured or gate was abandoned.
- static HRESULT WaitAll(Gate const * const *gates, int num_gates, DWORD msec);
-
- private:
- bool Initialize(const TCHAR * event_name);
- static HRESULT WaitMultipleHelper(Gate const * const *gates,
- int num_gates,
- DWORD msec,
- int *selected_gate,
- bool wait_all);
- HANDLE gate_;
- DISALLOW_EVIL_CONSTRUCTORS(Gate);
-};
-
-bool WaitAllowRepaint(const Gate& gate, DWORD msec);
-
-class AutoGateKeeper {
- public:
- explicit AutoGateKeeper(Gate *gate) : gate_(gate) {
- gate_->Open();
- }
- ~AutoGateKeeper() {
- gate_->Close();
- }
- private:
- Gate *gate_;
- DISALLOW_EVIL_CONSTRUCTORS(AutoGateKeeper);
-};
-
-// A very simple rather fast lock - if uncontested. USE ONLY AS A GLOBAL OBJECT
-// (i.e., DECLARED AT FILE SCOPE or as a STATIC CLASS MEMBER) - this is not
-// enforced. Uses interlocked instructions on an int to get a fast user-mode
-// lock. (Locks the bus and does a couple of memory references so it isn't
-// free.) Spin-waits to get the lock. Has the advantage that it needs no
-// initialization - thus has no order-of-evaluation problems with respect to
-// other global objects. Does not work (causes deadlock) if locked twice by
-// the same thread. (Has no constructor so is initialized to 0 by C++.
-// This is why it must be a global or static class member: it doesn't initialize
-// itself to 0. This is also why it doesn't inherit from Lockable, which would
-// make it need to initialize a virtual table.)
-struct SimpleLock {
- bool Lock() const;
- bool Unlock() const;
- private:
- mutable volatile long lock_;
-};
-
-struct SimpleLockWithDelay {
- bool Lock() const;
- bool Unlock() const;
- private:
- mutable volatile long lock_;
-};
-
-class AutoSimpleLock {
- public:
- explicit AutoSimpleLock(const SimpleLock& lock)
- : lock_(lock) { lock_.Lock(); }
- ~AutoSimpleLock() { lock_.Unlock(); }
- private:
- const SimpleLock& lock_;
- DISALLOW_EVIL_CONSTRUCTORS(AutoSimpleLock);
-};
-
-class AutoSimpleLockWithDelay {
- public:
- explicit AutoSimpleLockWithDelay(const SimpleLockWithDelay& lock)
- : lock_(lock) { lock_.Lock(); }
- ~AutoSimpleLockWithDelay() { lock_.Unlock(); }
- private:
- const SimpleLockWithDelay& lock_;
- DISALLOW_EVIL_CONSTRUCTORS(AutoSimpleLockWithDelay);
-};
-
-
-// allow only one thread to hold a lock
-class CriticalSection {
- public:
- CriticalSection();
- ~CriticalSection();
-
- void Enter();
- void Exit();
-
- private:
- CRITICAL_SECTION critical_section_;
- uint32 number_entries_;
-
- DISALLOW_EVIL_CONSTRUCTORS(CriticalSection);
-};
-
-// A class that manages a CriticalSection with its lifetime, you pass
-// it one in the constructor and then it will either be freed in the
-// destructor or implicitly [but only once]
-class SingleLock {
- public:
- // TODO(omaha): Not sure if immediately locking is a good idea;
- // the API is asymmetrical (there's an Unlock but no Lock).
-
- // Lock a critical section immediately
- explicit SingleLock(CriticalSection * cs);
-
- // If we have not explicitly unlocked it, this destructor will
- ~SingleLock();
-
- // Release the lock explicitly [should be called only once, after that
- // does nothing. If we do not do so, the destructor will]
- HRESULT Unlock();
-
- private:
- CriticalSection * critical_section_;
-
- DISALLOW_EVIL_CONSTRUCTORS(SingleLock);
-};
-
-// Encapsulation for kernel Event. Initializes and destroys with it's lifetime
-class EventObj {
- public:
- explicit EventObj(const TCHAR * event_name) {
- Init(event_name);
- }
- ~EventObj();
- void Init(const TCHAR * event_name);
- BOOL SetEvent();
- HANDLE GetHandle() { return h_; }
-
- private:
- HANDLE h_;
-
- DISALLOW_EVIL_CONSTRUCTORS(EventObj);
-};
-
-// Is the given handle signaled?
-//
-// Typically used for events.
-bool IsHandleSignaled(HANDLE h);
-
-
-enum SyncScope {
- // local to a session
- SYNC_LOCAL,
-
- // global scope but the name is decorated to make it unique for the user
- SYNC_USER,
-
- // a globally scoped name
- SYNC_GLOBAL,
-};
-
-// Create an id for the events/mutexes that can be used at the given scope
-void CreateSyncId(const TCHAR* id, SyncScope scope, CString* sync_id);
-
-// If any place needs to create a mutex that multiple
-// processes need to access, use this.
-HANDLE CreateMutexWithSyncAccess(const TCHAR* name,
- LPSECURITY_ATTRIBUTES lock_attributes);
-
-} // namespace omaha
-
-#endif // OMAHA_BASE_SYNCHRONIZED_H_
-
« no previous file with comments | « base/string_unittest.cc ('k') | base/synchronized.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698