Implement rudimentary touchscreen support in mus.

components/mus/ws/platform_screen_impl_ozone.cc

 // Copyright 2016 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/mus/ws/platform_screen_impl_ozone.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
@@ skipping 12 matching lines @@
 // Some ozone platforms do not configure physical displays and so do not
 // callback into this class via the implementation of NativeDisplayObserver.
 // FixedSizeScreenConfiguration() short-circuits the implementation of display
 // configuration in this case by calling the |callback| provided to
 // ConfigurePhysicalDisplay() with a hard-coded |id| and |bounds|.
 void FixedSizeScreenConfiguration(
     const PlatformScreen::ConfiguredDisplayCallback& callback) {
   callback.Run(1, gfx::Rect(1024, 768));
 }
 
-// The display subsystem calls |OnDisplayConfigured| for each display that has
-// been successfully configured. This in turn calls |callback_| with the
-// identity and bounds of each physical display.
-void OnDisplayConfigured(
-    const PlatformScreen::ConfiguredDisplayCallback& callback,
-    int64_t id,
-    const gfx::Rect& bounds,
-    bool success) {
-  if (success)
-    callback.Run(id, bounds);
-  else
-    LOG(FATAL) << "Failed to configure display at " << bounds.ToString();
+void GetDisplaysFinished(const std::vector<ui::DisplaySnapshot*>& displays) {
+  // We don't really care about list of displays, we just want the snapshots
+  // held by DrmDisplayManager to be updated. This only only happens when we
+  // call NativeDisplayDelegate::GetDisplays(). Although, this would be a good
+  // place to have PlatformScreen cache the snapshots if need be.
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<PlatformScreen> PlatformScreen::Create() {
   return base::WrapUnique(new PlatformScreenImplOzone);
 }
 
 PlatformScreenImplOzone::PlatformScreenImplOzone() : weak_ptr_factory_(this) {}
@@ skipping 15 matching lines @@
     // |PlatformScreenImplOzone|
 
     DCHECK(native_display_delegate_) << "DefaultDisplayManager::"
                                         "OnConfigurationChanged requires a "
                                         "native_display_delegate_ to work.";
 
     native_display_delegate_->GetDisplays(
         base::Bind(&PlatformScreenImplOzone::OnDisplaysAquired,
                    weak_ptr_factory_.GetWeakPtr(), callback));
 
-  } else
-#endif // defined(OS_CHROMEOS)
-    // PostTask()ed to maximize control flow similarity with the ChromeOS case.
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&FixedSizeScreenConfiguration, callback));
+    return;
+  }
+#endif  // defined(OS_CHROMEOS)
+  // PostTask()ed to maximize control flow similarity with the ChromeOS case.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&FixedSizeScreenConfiguration, callback));
 }
 
 void PlatformScreenImplOzone::OnConfigurationChanged() {}
 
 // The display subsystem calls |OnDisplaysAquired| to deliver |displays|
 // describing the attached displays.
 void PlatformScreenImplOzone::OnDisplaysAquired(
     const ConfiguredDisplayCallback& callback,
     const std::vector<ui::DisplaySnapshot*>& displays) {
   DCHECK(native_display_delegate_) << "DefaultDisplayManager::"
                                       "OnConfigurationChanged requires a "
                                       "native_display_delegate_ to work.";
   CHECK(displays.size() == 1) << "Mus only supports one 1 display\n";
   gfx::Point origin;
   for (auto display : displays) {
     if (!display->native_mode()) {
       LOG(ERROR) << "Display " << display->display_id()
                  << " doesn't have a native mode";
       continue;
     }
     // Setup each native display. This places a task on the DRM thread's
     // runqueue that configures the window size correctly before the call to
     // Configure.
     native_display_delegate_->Configure(
         *display, display->native_mode(), origin,
-        base::Bind(&OnDisplayConfigured, callback, display->display_id(),
+        base::Bind(&PlatformScreenImplOzone::OnDisplayConfigured,
+                   weak_ptr_factory_.GetWeakPtr(), callback,
+                   display->display_id(),
                    gfx::Rect(origin, display->native_mode()->size())));
     origin.Offset(display->native_mode()->size().width(), 0);
   }
 }
 
+void PlatformScreenImplOzone::OnDisplayConfigured(
+    const ConfiguredDisplayCallback& callback,
+    int64_t id,
+    const gfx::Rect& bounds,
+    bool success) {
+  if (success) {
+    native_display_delegate_->GetDisplays(base::Bind(&GetDisplaysFinished));
+    callback.Run(id, bounds);
+  } else {
+    LOG(FATAL) << "Failed to configure display at " << bounds.ToString();
+  }
+}
+
 }  // namespace ws
 }  // namespace mus