Move components/display_compositor to components/viz/display_compositor

components/viz/display_compositor/host_shared_bitmap_manager.cc

 // Copyright 2013 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 "components/display_compositor/host_shared_bitmap_manager.h"
+#include "components/viz/display_compositor/host_shared_bitmap_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "build/build_config.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "ui/gfx/geometry/size.h"
 
-namespace display_compositor {
+namespace viz {
 
 class BitmapData : public base::RefCountedThreadSafe<BitmapData> {
  public:
   explicit BitmapData(size_t buffer_size) : buffer_size(buffer_size) {}
   std::unique_ptr<base::SharedMemory> memory;
   std::unique_ptr<uint8_t[]> pixels;
   size_t buffer_size;
 
  private:
   friend class base::RefCountedThreadSafe<BitmapData>;
@@ skipping 79 matching lines @@
 
 HostSharedBitmapManager* HostSharedBitmapManager::current() {
   return g_shared_memory_manager.Pointer();
 }
 
 std::unique_ptr<cc::SharedBitmap> HostSharedBitmapManager::AllocateSharedBitmap(
     const gfx::Size& size) {
   base::AutoLock lock(lock_);
   size_t bitmap_size;
   if (!cc::SharedBitmap::SizeInBytes(size, &bitmap_size))
-    return std::unique_ptr<cc::SharedBitmap>();
+    return nullptr;
 
   scoped_refptr<BitmapData> data(new BitmapData(bitmap_size));
   // Bitmaps allocated in host don't need to be shared to other processes, so
   // allocate them with new instead.
   data->pixels = std::unique_ptr<uint8_t[]>(new uint8_t[bitmap_size]);
 
   cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
   handle_map_[id] = data;
   return base::MakeUnique<HostSharedBitmap>(data->pixels.get(), data, id, this);
 }
 
 std::unique_ptr<cc::SharedBitmap>
 HostSharedBitmapManager::GetSharedBitmapFromId(const gfx::Size& size,
                                                const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   BitmapMap::iterator it = handle_map_.find(id);
   if (it == handle_map_.end())
-    return std::unique_ptr<cc::SharedBitmap>();
+    return nullptr;
 
   BitmapData* data = it->second.get();
 
   size_t bitmap_size;
   if (!cc::SharedBitmap::SizeInBytes(size, &bitmap_size) ||
       bitmap_size > data->buffer_size)
-    return std::unique_ptr<cc::SharedBitmap>();
+    return nullptr;
 
   if (data->pixels) {
     return base::MakeUnique<HostSharedBitmap>(data->pixels.get(), data, id,
                                               nullptr);
   }
   if (!data->memory->memory()) {
-    return std::unique_ptr<cc::SharedBitmap>();
+    return nullptr;
   }
 
   return base::MakeUnique<HostSharedBitmap>(
       static_cast<uint8_t*>(data->memory->memory()), data, id, nullptr);
 }
 
 bool HostSharedBitmapManager::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   base::AutoLock lock(lock_);
@@ skipping 47 matching lines @@
   base::AutoLock lock(lock_);
   return handle_map_.size();
 }
 
 void HostSharedBitmapManager::FreeSharedMemoryFromMap(
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   handle_map_.erase(id);
 }
 
-}  // namespace display_compositor
+}  // namespace viz