Fix static initializers in ClipboardAura.

ui/base/clipboard/clipboard_aura.cc

 // Copyright (c) 2012 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.
 
 #include "ui/base/clipboard/clipboard_aura.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <list>
 #include <memory>
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/clipboard/clipboard_monitor.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace ui {
 
 namespace {
+
 const char kMimeTypeFilename[] = "chromium/filename";
 const char kMimeTypeBitmap[] = "image/bmp";
 const size_t kMaxClipboardSize = 1;
 
 // Clipboard data format used by AuraClipboard.
 enum AuraClipboardFormat {
   TEXT      = 1 << 0,
   HTML      = 1 << 1,
   RTF       = 1 << 2,
   BOOKMARK  = 1 << 3,
@@ skipping 254 matching lines @@
   void WriteData(std::unique_ptr<ClipboardData> data) {
     DCHECK(data);
     AddToListEnsuringSize(std::move(data));
     ClipboardMonitor::GetInstance()->NotifyClipboardDataChanged();
   }
 
  private:
   // True if the data on top of the clipboard stack has format |format|.
   bool HasFormat(AuraClipboardFormat format) const {
     const ClipboardData* data = GetData();
-    if (!data)
-      return false;
-
-    return data->format() & format;
+    return data ? data->format() & format : false;
   }
 
   void AddToListEnsuringSize(std::unique_ptr<ClipboardData> data) {
     DCHECK(data);
     sequence_number_++;
     data_list_.push_front(std::move(data));
 
     // If the size of list becomes more than the maximum allowed, we delete the
     // last element.
     if (data_list_.size() > kMaxClipboardSize) {
       data_list_.pop_back();
     }
   }
 
   // Stack containing various versions of ClipboardData.
   std::list<std::unique_ptr<ClipboardData>> data_list_;
 
   // Sequence number uniquely identifying clipboard state.
   uint64_t sequence_number_;
 
   DISALLOW_COPY_AND_ASSIGN(AuraClipboard);
 };
 
-AuraClipboard* aura_clipboard = NULL;
+AuraClipboard* g_aura_clipboard = NULL;
 
 AuraClipboard* GetClipboard() {
-  if (!aura_clipboard)
-    aura_clipboard = new AuraClipboard();
-  return aura_clipboard;
+  if (!g_aura_clipboard)
+    g_aura_clipboard = new AuraClipboard();
+  return g_aura_clipboard;
 }
 
 void DeleteClipboard() {
-  if (aura_clipboard)
-    delete aura_clipboard;
-  aura_clipboard = NULL;
+  delete g_aura_clipboard;
+  g_aura_clipboard = NULL;
 }
 
 // Helper class to build a ClipboardData object and write it to clipboard.
 class ClipboardDataBuilder {
  public:
   static void CommitToClipboard() {
-    // Make sure there is always a valid ClipboardData object attached to
-    // current_data_.
-    GetCurrentData();
-    GetClipboard()->WriteData(std::move(current_data_));
+    GetClipboard()->WriteData(TakeCurrentData());
   }
 
   static void WriteText(const char* text_data, size_t text_len) {
     ClipboardData* data = GetCurrentData();
     data->set_text(std::string(text_data, text_len));
   }
 
   static void WriteHTML(const char* markup_data,
                         size_t markup_len,
                         const char* url_data,
@@ skipping 30 matching lines @@
   static void WriteData(const std::string& format,
                         const char* data_data,
                         size_t data_len) {
     ClipboardData* data = GetCurrentData();
     data->SetCustomData(format, std::string(data_data, data_len));
   }
 
  private:
   static ClipboardData* GetCurrentData() {
     if (!current_data_)
-      current_data_.reset(new ClipboardData);
-    return current_data_.get();
+      current_data_ = new ClipboardData;
+    return current_data_;
   }
 
-  static std::unique_ptr<ClipboardData> current_data_;
+  static std::unique_ptr<ClipboardData> TakeCurrentData() {
+    std::unique_ptr<ClipboardData> data = base::WrapUnique(GetCurrentData());
+    current_data_ = nullptr;
+    return data;
+  }
+  // This is a raw pointer instead of a std::unique_ptr to avoid adding a
+  // static initializer.
+  static ClipboardData* current_data_;
 };
 
-std::unique_ptr<ClipboardData> ClipboardDataBuilder::current_data_;
+ClipboardData* ClipboardDataBuilder::current_data_ = nullptr;
 
 }  // namespace
 
 // Clipboard::FormatType implementation.
 Clipboard::FormatType::FormatType() {
 }
 
 Clipboard::FormatType::FormatType(const std::string& native_format)
     : data_(native_format) {
 }
@@ skipping 126 matching lines @@
 }
 
 bool ClipboardAura::IsFormatAvailable(const FormatType& format,
                                       ClipboardType type) const {
   DCHECK(CalledOnValidThread());
   DCHECK(IsSupportedClipboardType(type));
   AuraClipboard* clipboard = GetClipboard();
   if (GetPlainTextFormatType().Equals(format) ||
       GetUrlFormatType().Equals(format))
     return clipboard->IsFormatAvailable(TEXT);
-  else if (GetHtmlFormatType().Equals(format))
+  if (GetHtmlFormatType().Equals(format))
     return clipboard->IsFormatAvailable(HTML);
-  else if (GetRtfFormatType().Equals(format))
+  if (GetRtfFormatType().Equals(format))
     return clipboard->IsFormatAvailable(RTF);
-  else if (GetBitmapFormatType().Equals(format))
+  if (GetBitmapFormatType().Equals(format))
     return clipboard->IsFormatAvailable(BITMAP);
-  else if (GetWebKitSmartPasteFormatType().Equals(format))
+  if (GetWebKitSmartPasteFormatType().Equals(format))
     return clipboard->IsFormatAvailable(WEB);
-  else {
-    const ClipboardData* data = clipboard->GetData();
-    if (data && data->custom_data_format() == format.ToString())
-      return true;
-  }
-  return false;
+  const ClipboardData* data = clipboard->GetData();
+  return data && data->custom_data_format() == format.ToString();
 }
 
 void ClipboardAura::Clear(ClipboardType type) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsSupportedClipboardType(type));
   AuraClipboard* clipboard = GetClipboard();
   clipboard->Clear();
 }
 
 void ClipboardAura::ReadAvailableTypes(ClipboardType type,
@@ skipping 112 matching lines @@
   ClipboardDataBuilder::WriteBitmap(bitmap);
 }
 
 void ClipboardAura::WriteData(const FormatType& format,
                               const char* data_data,
                               size_t data_len) {
   ClipboardDataBuilder::WriteData(format.ToString(), data_data, data_len);
 }
 
 }  // namespace ui