http: Do a pending c++11 simplification

laanwj · laanwj · commit 091d6e04998d · 2016-05-05T08:27:12.000+02:00
Use std::unique_ptr for handling work items.

This makes the code more RAII and, as mentioned in the comment, is what
I planned when I wrote the code in the first place.
diff --git a/src/httpserver.cpp b/src/httpserver.cpp
@@ -71,8 +71,7 @@ class WorkQueue
     /** Mutex protects entire object */
     CWaitableCriticalSection cs;
     CConditionVariable cond;
-    /* XXX in C++11 we can use std::unique_ptr here and avoid manual cleanup */
-    std::deque<WorkItem*> queue;
+    std::deque<std::unique_ptr<WorkItem>> queue;
     bool running;
     size_t maxDepth;
     int numThreads;
@@ -101,15 +100,11 @@ class WorkQueue
                                  numThreads(0)
     {
     }
-    /*( Precondition: worker threads have all stopped
+    /** Precondition: worker threads have all stopped
      * (call WaitExit)
      */
     ~WorkQueue()
     {
-        while (!queue.empty()) {
-            delete queue.front();
-            queue.pop_front();
-        }
     }
     /** Enqueue a work item */
     bool Enqueue(WorkItem* item)
@@ -118,7 +113,7 @@ class WorkQueue
         if (queue.size() >= maxDepth) {
             return false;
         }
-        queue.push_back(item);
+        queue.emplace_back(std::unique_ptr<WorkItem>(item));
         cond.notify_one();
         return true;
     }
@@ -127,18 +122,17 @@ class WorkQueue
     {
         ThreadCounter count(*this);
         while (running) {
-            WorkItem* i = 0;
+            std::unique_ptr<WorkItem> i;
             {
                 boost::unique_lock<boost::mutex> lock(cs);
                 while (running && queue.empty())
                     cond.wait(lock);
                 if (!running)
                     break;
-                i = queue.front();
+                i = std::move(queue.front());
                 queue.pop_front();
             }
             (*i)();
-            delete i;
         }
     }
     /** Interrupt and exit loops */

Original file line number	Diff line number	Diff line change
`@@ -71,8 +71,7 @@ class WorkQueue`
`71`	`71`	`/** Mutex protects entire object */`
`72`	`72`	`CWaitableCriticalSection cs;`
`73`	`73`	`CConditionVariable cond;`
`74`		`- /* XXX in C++11 we can use std::unique_ptr here and avoid manual cleanup */`
`75`		`- std::deque<WorkItem*> queue;`
	`74`	`+ std::deque<std::unique_ptr<WorkItem>> queue;`
`76`	`75`	`bool running;`
`77`	`76`	`size_t maxDepth;`
`78`	`77`	`int numThreads;`
`@@ -101,15 +100,11 @@ class WorkQueue`
`101`	`100`	`numThreads(0)`
`102`	`101`	`{`
`103`	`102`	`}`
`104`		`- /*( Precondition: worker threads have all stopped`
	`103`	`+ /** Precondition: worker threads have all stopped`
`105`	`104`	`* (call WaitExit)`
`106`	`105`	`*/`
`107`	`106`	`~WorkQueue()`
`108`	`107`	`{`
`109`		`- while (!queue.empty()) {`
`110`		`- delete queue.front();`
`111`		`- queue.pop_front();`
`112`		`- }`
`113`	`108`	`}`
`114`	`109`	`/** Enqueue a work item */`
`115`	`110`	`bool Enqueue(WorkItem* item)`
`@@ -118,7 +113,7 @@ class WorkQueue`
`118`	`113`	`if (queue.size() >= maxDepth) {`
`119`	`114`	`return false;`
`120`	`115`	`}`
`121`		`- queue.push_back(item);`
	`116`	`+ queue.emplace_back(std::unique_ptr<WorkItem>(item));`
`122`	`117`	`cond.notify_one();`
`123`	`118`	`return true;`
`124`	`119`	`}`
`@@ -127,18 +122,17 @@ class WorkQueue`
`127`	`122`	`{`
`128`	`123`	`ThreadCounter count(*this);`
`129`	`124`	`while (running) {`
`130`		`- WorkItem* i = 0;`
	`125`	`+ std::unique_ptr<WorkItem> i;`
`131`	`126`	`{`
`132`	`127`	`boost::unique_lock<boost::mutex> lock(cs);`
`133`	`128`	`while (running && queue.empty())`
`134`	`129`	`cond.wait(lock);`
`135`	`130`	`if (!running)`
`136`	`131`	`break;`
`137`		`- i = queue.front();`
	`132`	`+ i = std::move(queue.front());`
`138`	`133`	`queue.pop_front();`
`139`	`134`	`}`
`140`	`135`	`(*i)();`
`141`		`- delete i;`
`142`	`136`	`}`
`143`	`137`	`}`
`144`	`138`	`/** Interrupt and exit loops */`