Clean up some confusing naming of ClipboardLock. It isn't a lock, and the wa...

base/clipboard_win.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Many of these functions are based on those found in
 // webkit/port/platform/PasteboardWin.cpp
 
 #include <shlobj.h>
 #include <shellapi.h>
 
 #include "base/clipboard.h"
 
 #include "base/clipboard_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 
 namespace {
 
-// A small object to ensure we close the clipboard after opening it.
-class ClipboardLock {
+// A scoper to manage acquiring and automatically releasing the clipboard.
+class ScopedClipboard {
  public:
-  ClipboardLock() : we_own_the_lock_(false) { }
+  ScopedClipboard() : opened_(false) { }
 
-  ~ClipboardLock() {
-    if (we_own_the_lock_)
+  ~ScopedClipboard() {
+    if (opened_)
       Release();
   }
 
   bool Acquire(HWND owner) {
-    // We shouldn't be calling this if we already own the clipboard lock.
-    DCHECK(!we_own_the_lock_);
-
-    // We already have the lock.  We don't want to stomp on the other use.
-    if (we_own_the_lock_)
-      return false;
-
     const int kMaxAttemptsToOpenClipboard = 5;
 
-    // Attempt to acquire the clipboard lock.  This may fail if another process
-    // currently holds the lock.  We're willing to try a few times in the hopes
-    // of acquiring it.
+    if (opened_) {
+      NOTREACHED();
+      return false;
+    }
+
+    // Attempt to open the clipboard, which will acquire the Windows clipboard
+    // lock.  This may fail if another process currently holds this lock.
+    // We're willing to try a few times in the hopes of acquiring it.
     //
     // This turns out to be an issue when using remote desktop because the
     // rdpclip.exe process likes to read what we've written to the clipboard and
     // send it to the RDP client.  If we open and close the clipboard in quick
     // succession, we might be trying to open it while rdpclip.exe has it open,
     // See Bug 815425.
     //
     // In fact, we believe we'll only spin this loop over remote desktop.  In
     // normal situations, the user is initiating clipboard operations and there
-    // shouldn't be lock contention.
+    // shouldn't be contention.
 
     for (int attempts = 0; attempts < kMaxAttemptsToOpenClipboard; ++attempts) {
+      // If we didn't manage to open the clipboard, sleep a bit and be hopeful.
+      if (attempts != 0)
+        ::Sleep(5);
+
       if (::OpenClipboard(owner)) {
-        we_own_the_lock_ = true;
-        return we_own_the_lock_;
+        opened_ = true;
+        return true;
       }
-
-      // Having failed, we yield our timeslice to other processes. ::Yield seems
-      // to be insufficient here, so we sleep for 5 ms.
-      if (attempts < (kMaxAttemptsToOpenClipboard - 1))
-        ::Sleep(5);
     }
 
     // We failed to acquire the clipboard.
     return false;
   }
 
   void Release() {
-    // We should only be calling this if we already own the clipboard lock.
-    DCHECK(we_own_the_lock_);
-
-    // We we don't have the lock, there is nothing to release.
-    if (!we_own_the_lock_)
-      return;
-
-    ::CloseClipboard();
-    we_own_the_lock_ = false;
+    if (opened_) {
+      ::CloseClipboard();
+      opened_ = false;
+    } else {
+      NOTREACHED();
+    }
   }
 
  private:
-  bool we_own_the_lock_;
+  bool opened_;
 };
 
 LRESULT CALLBACK ClipboardOwnerWndProc(HWND hwnd,
                                        UINT message,
                                        WPARAM wparam,
                                        LPARAM lparam) {
   LRESULT lresult = 0;
 
   switch(message) {
   case WM_RENDERFORMAT:
@@ skipping 54 matching lines @@
 Clipboard::~Clipboard() {
   ::DestroyWindow(clipboard_owner_);
   clipboard_owner_ = NULL;
 }
 
 void Clipboard::WriteObjects(const ObjectMap& objects) {
   WriteObjects(objects, NULL);
 }
 
 void Clipboard::WriteObjects(const ObjectMap& objects, ProcessHandle process) {
-  ClipboardLock lock;
-  if (!lock.Acquire(clipboard_owner_))
+  ScopedClipboard clipboard;
+  if (!clipboard.Acquire(clipboard_owner_))
     return;
 
   ::EmptyClipboard();
 
   for (ObjectMap::const_iterator iter = objects.begin();
        iter != objects.end(); ++iter) {
     if (iter->first == CBF_SMBITMAP)
       WriteBitmapFromSharedMemory(&(iter->second[0].front()),
                                   &(iter->second[1].front()),
                                   process);
@@ skipping 214 matching lines @@
 
 void Clipboard::ReadText(std::wstring* result) const {
   if (!result) {
     NOTREACHED();
     return;
   }
 
   result->clear();
 
   // Acquire the clipboard.
-  ClipboardLock lock;
-  if (!lock.Acquire(clipboard_owner_))
+  ScopedClipboard clipboard;
+  if (!clipboard.Acquire(clipboard_owner_))
     return;
 
   HANDLE data = ::GetClipboardData(CF_UNICODETEXT);
   if (!data)
     return;
 
   result->assign(static_cast<const wchar_t*>(::GlobalLock(data)));
   ::GlobalUnlock(data);
 }
 
 void Clipboard::ReadAsciiText(std::string* result) const {
   if (!result) {
     NOTREACHED();
     return;
   }
 
   result->clear();
 
   // Acquire the clipboard.
-  ClipboardLock lock;
-  if (!lock.Acquire(clipboard_owner_))
+  ScopedClipboard clipboard;
+  if (!clipboard.Acquire(clipboard_owner_))
     return;
 
   HANDLE data = ::GetClipboardData(CF_TEXT);
   if (!data)
     return;
 
   result->assign(static_cast<const char*>(::GlobalLock(data)));
   ::GlobalUnlock(data);
 }
 
 void Clipboard::ReadHTML(std::wstring* markup, std::string* src_url) const {
   if (markup)
     markup->clear();
 
   if (src_url)
     src_url->clear();
 
   // Acquire the clipboard.
-  ClipboardLock lock;
-  if (!lock.Acquire(clipboard_owner_))
+  ScopedClipboard clipboard;
+  if (!clipboard.Acquire(clipboard_owner_))
     return;
 
   HANDLE data = ::GetClipboardData(GetHtmlFormatType());
   if (!data)
     return;
 
   std::string html_fragment(static_cast<const char*>(::GlobalLock(data)));
   ::GlobalUnlock(data);
 
   ParseHTMLClipboardFormat(html_fragment, markup, src_url);
 }
 
 void Clipboard::ReadBookmark(std::wstring* title, std::string* url) const {
   if (title)
     title->clear();
 
   if (url)
     url->clear();
 
   // Acquire the clipboard.
-  ClipboardLock lock;
-  if (!lock.Acquire(clipboard_owner_))
+  ScopedClipboard clipboard;
+  if (!clipboard.Acquire(clipboard_owner_))
     return;
 
   HANDLE data = ::GetClipboardData(GetUrlWFormatType());
   if (!data)
     return;
 
   std::wstring bookmark(static_cast<const wchar_t*>(::GlobalLock(data)));
   ::GlobalUnlock(data);
 
   ParseBookmarkClipboardFormat(bookmark, title, url);
@@ skipping 17 matching lines @@
 
 // Read a set of files in HDROP format from the clipboard.
 void Clipboard::ReadFiles(std::vector<std::wstring>* files) const {
   if (!files) {
     NOTREACHED();
     return;
   }
 
   files->clear();
 
-  ClipboardLock lock;
-  if (!lock.Acquire(clipboard_owner_))
+  ScopedClipboard clipboard;
+  if (!clipboard.Acquire(clipboard_owner_))
     return;
 
   HDROP drop = static_cast<HDROP>(::GetClipboardData(CF_HDROP));
   if (!drop)
     return;
 
   // Count of files in the HDROP.
   int count = ::DragQueryFile(drop, 0xffffffff, NULL, 0);
 
   if (count) {
@@ skipping 193 matching lines @@
   return ClipboardUtil::GetWebKitSmartPasteFormat()->cfFormat;
 }
 
 // static
 void Clipboard::FreeData(FormatType format, HANDLE data) {
   if (format == CF_BITMAP)
     ::DeleteObject(static_cast<HBITMAP>(data));
   else
     ::GlobalFree(data);
 }