Reland of: [Ozone-GBM] Handle GPU crashes

ui/ozone/platform/dri/chromeos/display_message_handler.cc

 // Copyright 2014 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/ozone/platform/dri/chromeos/display_message_handler.h"
 
 #include "ui/display/types/chromeos/display_mode.h"
 #include "ui/display/types/chromeos/display_snapshot.h"
 #include "ui/ozone/common/chromeos/display_util.h"
 #include "ui/ozone/common/gpu/ozone_gpu_message_params.h"
 #include "ui/ozone/common/gpu/ozone_gpu_messages.h"
 #include "ui/ozone/platform/dri/chromeos/native_display_delegate_dri.h"
 
 namespace ui {
 
+namespace {
+
+class FindDisplayById {
+ public:
+  FindDisplayById(int64_t display_id) : display_id_(display_id) {}
+
+  bool operator()(const DisplaySnapshot_Params& display) const {
+    return display.display_id == display_id_;
+  }
+
+ private:
+  int64_t display_id_;
+};
+
+}  // namespace
+
 DisplayMessageHandler::DisplayMessageHandler(
     scoped_ptr<NativeDisplayDelegateDri> ndd)
     : sender_(NULL),
       ndd_(ndd.Pass()) {}
 
 DisplayMessageHandler::~DisplayMessageHandler() {}
 
 void DisplayMessageHandler::OnChannelEstablished(IPC::Sender* sender) {
   sender_ = sender;
 }
@@ skipping 12 matching lines @@
   IPC_MESSAGE_UNHANDLED(handled = false);
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void DisplayMessageHandler::OnForceDPMSOn() {
   ndd_->ForceDPMSOn();
 }
 
-void DisplayMessageHandler::OnRefreshNativeDisplays() {
+void DisplayMessageHandler::OnRefreshNativeDisplays(

[spang, 2014/09/08 22:49:17]

There's now a big overlap between RefreshNativeDisplays and Configure/Disable.
In fact it looks like Configure/Disable are now redundant, and should just be
removed.

You'd have just one combined operation: send me the desired configuration, and
then return the actual configuration once complete.

[dnicoara, 2014/09/09 14:29:28]

Not quite. RefreshNativeDisplays is passed a stale configuration (and possibly
none) and is used as a trigger to refresh the configuration. Whereas
Configure/Disable are called right after probing for configuration changes.

This would be the call sequence:

1) Browser: Display hotplug event -> send RefreshNativeDisplays IPC
2) GPU: OnRefreshNativeDisplays -> query driver for configuration changes
3) GPU: Send updated list of displays -> send UpdateNativeDisplays(...)
4) Browser: OnUpdateNativeDisplays -> Configure/Disable displays

In case of GPU crashes only the browser process knows the configuration, so it
needs to update the GPU side accordingly. For simplicity this is done in
OnRefreshNativeDisplays.

[spang, 2014/09/09 14:44:25]

What do you mean by stale configuration? Does it actually matter?

GPU crash means you need a way to sync the whole state from browser to GPU. So
you've bolted that onto refresh. This seems fine, there's no reason not to do
them both in one go.

However if you have a way to sync the whole state, then you don't also need a
way to update parts of it. The duplication here is unwarranted.

Just have one path, that synchronizes everything. Browser sending an incomplete
configuration can be handled easily.

[dnicoara, 2014/09/09 15:10:00]

The configuration could be nothing (since CrOS just started up) or the last
polled configuration (which could have happened hours ago).
OnRefreshNativeDisplays is called in the following 2 cases:
1) On hotplug event,
2) On GPU restart.

For (1) the configuration known to the browser process is stale, so the browser
process needs to get the new one before it can make a decision.

For (2) the configuration is likely the same and we only want to sync the state
across processes.

+    const std::vector<DisplaySnapshot_Params>& cached_displays) {
   std::vector<DisplaySnapshot_Params> displays;
   std::vector<DisplaySnapshot*> native_displays = ndd_->GetDisplays();
+
+  // If any of the cached displays are in the list of new displays then apply
+  // their configuration immediately.
+  for (size_t i = 0; i < native_displays.size(); ++i) {
+    std::vector<DisplaySnapshot_Params>::const_iterator it =
+        std::find_if(cached_displays.begin(),
+                     cached_displays.end(),
+                     FindDisplayById(native_displays[i]->display_id()));
+
+    if (it == cached_displays.end())
+      continue;
+
+    if (it->has_current_mode)
+      OnConfigureNativeDisplay(it->display_id, it->current_mode, it->origin);
+    else
+      OnDisableNativeDisplay(it->display_id);
+  }
+
   for (size_t i = 0; i < native_displays.size(); ++i)
     displays.push_back(GetDisplaySnapshotParams(*native_displays[i]));
 
   sender_->Send(new OzoneHostMsg_UpdateNativeDisplays(displays));
 }
 
 void DisplayMessageHandler::OnConfigureNativeDisplay(
     int64_t id,
     const DisplayMode_Params& mode_param,
     const gfx::Point& origin) {
@@ skipping 34 matching lines @@
 
 void DisplayMessageHandler::OnDisableNativeDisplay(int64_t id) {
   DisplaySnapshot* display = ndd_->FindDisplaySnapshot(id);
   if (display)
     ndd_->Configure(*display, NULL, gfx::Point());
   else
     LOG(ERROR) << "There is no display with ID " << id;
 }
 
 }  // namespace ui