Normalize the format of DVLOG(1) messages in window_tree.cc.

services/ui/ws/window_tree.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 "services/ui/ws/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 366 matching lines @@
   return display_root->window_manager_state()->SetCapture(nullptr,
                                                           kInvalidClientId);
 }
 
 bool WindowTree::NewWindow(
     const ClientWindowId& client_window_id,
     const std::map<std::string, std::vector<uint8_t>>& properties) {
   DVLOG(3) << "new window client=" << id_
            << " window_id=" << client_window_id.id;
   if (!IsValidIdForNewWindow(client_window_id)) {
-    DVLOG(1) << "new window failed, id is not valid for client";
+    DVLOG(1) << "NewWindow failed (id is not valid for client)";
     return false;
   }
   const WindowId window_id = GenerateNewWindowId();
   DCHECK(!GetWindow(window_id));
   ServerWindow* window =
       window_server_->CreateServerWindow(window_id, properties);
   created_window_map_[window_id] = window;
   client_id_to_window_id_map_[client_window_id] = window_id;
   window_id_to_client_id_map_[window_id] = client_window_id;
   return true;
 }
 
 bool WindowTree::AddWindow(const ClientWindowId& parent_id,
                            const ClientWindowId& child_id) {
   ServerWindow* parent = GetWindowByClientId(parent_id);
   ServerWindow* child = GetWindowByClientId(child_id);
   DVLOG(3) << "add window client=" << id_
            << " client parent window_id=" << parent_id.id
            << " global window_id="
            << (parent ? WindowIdToTransportId(parent->id()) : 0)
            << " client child window_id= " << child_id.id << " global window_id="
            << (child ? WindowIdToTransportId(child->id()) : 0);
   if (!parent) {
-    DVLOG(1) << "add failed, no parent";
+    DVLOG(1) << "AddWindow failed (no parent)";
     return false;
   }
   if (!child) {
-    DVLOG(1) << "add failed, no child";
+    DVLOG(1) << "AddWindow failed (no child)";
     return false;
   }
   if (child->parent() == parent) {
-    DVLOG(1) << "add failed, already has parent";
+    DVLOG(1) << "AddWindow failed (already has parent)";
     return false;
   }
   if (child->Contains(parent)) {
-    DVLOG(1) << "add failed, child contains parent";
+    DVLOG(1) << "AddWindow failed (child contains parent)";
     return false;
   }
   if (!access_policy_->CanAddWindow(parent, child)) {
-    DVLOG(1) << "add failed, access policy denied add";
+    DVLOG(1) << "AddWindow failed (access denied)";
     return false;
   }
   Operation op(this, window_server_, OperationType::ADD_WINDOW);
   parent->Add(child);
   return true;
 }
 
 bool WindowTree::AddTransientWindow(const ClientWindowId& window_id,
                                     const ClientWindowId& transient_window_id) {
   ServerWindow* window = GetWindowByClientId(window_id);
@@ skipping 94 matching lines @@
   return windows;
 }
 
 bool WindowTree::SetWindowVisibility(const ClientWindowId& window_id,
                                      bool visible) {
   ServerWindow* window = GetWindowByClientId(window_id);
   DVLOG(3) << "SetWindowVisibility client=" << id_
            << " client window_id= " << window_id.id << " global window_id="
            << (window ? WindowIdToTransportId(window->id()) : 0);
   if (!window) {
-    DVLOG(1) << "SetWindowVisibility failure, no window";
+    DVLOG(1) << "SetWindowVisibility failed (no window)";
     return false;
   }
   if (!access_policy_->CanChangeWindowVisibility(window)) {
-    DVLOG(1) << "SetWindowVisibility failure, access policy denied change";
+    DVLOG(1) << "SetWindowVisibility failed (access policy denied change)";
     return false;
   }
   if (window->visible() == visible)
     return true;
   Operation op(this, window_server_, OperationType::SET_WINDOW_VISIBILITY);
   window->SetVisible(visible);
   return true;
 }
 
 bool WindowTree::SetWindowOpacity(const ClientWindowId& window_id,
                                   float opacity) {
   ServerWindow* window = GetWindowByClientId(window_id);
   if (!window || !access_policy_->CanChangeWindowOpacity(window))
     return false;
   if (window->opacity() == opacity)
     return true;
   Operation op(this, window_server_, OperationType::SET_WINDOW_OPACITY);
   window->SetOpacity(opacity);
   return true;
 }
 
 bool WindowTree::SetFocus(const ClientWindowId& window_id) {
   ServerWindow* window = GetWindowByClientId(window_id);
   ServerWindow* currently_focused = window_server_->GetFocusedWindow();
   if (!currently_focused && !window) {
-    DVLOG(1) << "SetFocus failure, no focused window to clear.";
+    DVLOG(1) << "SetFocus failed (no focused window to clear)";
     return false;
   }
 
   Display* display = GetDisplay(window);
   if (window && (!display || !window->can_focus() || !window->IsDrawn())) {
-    DVLOG(1) << "SetFocus failure, window cannot be focused.";
+    DVLOG(1) << "SetFocus failed (window cannot be focused)";
     return false;
   }
 
   if (!access_policy_->CanSetFocus(window)) {
-    DVLOG(1) << "SetFocus failure, blocked by access policy.";
+    DVLOG(1) << "SetFocus failed (blocked by access policy)";
     return false;
   }
 
   Operation op(this, window_server_, OperationType::SET_FOCUS);
   bool success = window_server_->SetFocusedWindow(window);
   if (!success) {
-    DVLOG(1) << "SetFocus failure, could not SetFocusedWindow.";
+    DVLOG(1) << "SetFocus failed (could not SetFocusedWindow)";
   }
   return success;
 }
 
 bool WindowTree::Embed(const ClientWindowId& window_id,
                        mojom::WindowTreeClientPtr window_tree_client,
                        uint32_t flags) {
   if (!window_tree_client || !CanEmbed(window_id))
     return false;
   ServerWindow* window = GetWindowByClientId(window_id);
@@ skipping 62 matching lines @@
   const bool drawn = window->parent() && window->parent()->IsDrawn();
   client()->OnTopLevelCreated(client_change_id, WindowToWindowData(window),
                               display_id, drawn, window->frame_sink_id(),
                               window->current_local_surface_id());
 }
 
 void WindowTree::AddActivationParent(const ClientWindowId& window_id) {
   ServerWindow* window = GetWindowByClientId(window_id);
   if (window) {
     Display* display = GetDisplay(window);
-    if (display)
+    if (display) {
       display->AddActivationParent(window);
-    else
-      DVLOG(1) << "AddActivationParent window not associated with display";
+    } else {
+      DVLOG(1) << "AddActivationParent failed "
+               << "(window not associated with display)";
+    }
   } else {
-    DVLOG(1) << "AddActivationParent supplied invalid window id";
+    DVLOG(1) << "AddActivationParent failed (invalid window id)";
   }
 }
 
 void WindowTree::OnChangeCompleted(uint32_t change_id, bool success) {
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::OnAccelerator(uint32_t accelerator_id,
                                const ui::Event& event,
                                AcceleratorCallback callback) {
@@ skipping 351 matching lines @@
 
 WindowId WindowTree::GenerateNewWindowId() {
   // TODO(sky): deal with wrapping and uniqueness.
   return WindowId(id_, next_window_id_++);
 }
 
 bool WindowTree::CanReorderWindow(const ServerWindow* window,
                                   const ServerWindow* relative_window,
                                   mojom::OrderDirection direction) const {
   if (!window) {
-    DVLOG(1) << "reorder failing: invalid window";
+    DVLOG(1) << "CanReorderWindow failed (invalid window)";
     return false;
   }
   if (!relative_window) {
-    DVLOG(1) << "reorder failing: invalid relative window";
+    DVLOG(1) << "CanReorderWindow failed (invalid relative window)";
     return false;
   }
 
   if (!window->parent()) {
-    DVLOG(1) << "reorder failing: no parent";
+    DVLOG(1) << "CanReorderWindow failed (no parent)";
     return false;
   }
 
   if (window->parent() != relative_window->parent()) {
-    DVLOG(1) << "reorder failing: parents differ";
+    DVLOG(1) << "CanReorderWindow failed (parents differ)";
     return false;
   }
 
   if (!access_policy_->CanReorderWindow(window, relative_window, direction)) {
-    DVLOG(1) << "reorder failing: access policy denied";
+    DVLOG(1) << "CanReorderWindow failed (access policy denied)";
     return false;
   }
 
   const ServerWindow::Windows& children = window->parent()->children();
   const size_t child_i =
       std::find(children.begin(), children.end(), window) - children.begin();
   const size_t target_i =
       std::find(children.begin(), children.end(), relative_window) -
       children.begin();
   if ((direction == mojom::OrderDirection::ABOVE && child_i == target_i + 1) ||
       (direction == mojom::OrderDirection::BELOW && child_i + 1 == target_i)) {
-    DVLOG(1) << "reorder failing: already in position";
+    DVLOG(1) << "CanReorderWindow failed (already in position)";
     return false;
   }
 
   return true;
 }
 
 bool WindowTree::DeleteWindowImpl(WindowTree* source, ServerWindow* window) {
   DCHECK(window);
   DCHECK_EQ(window->id().client_id, id_);
   Operation op(source, window_server_, OperationType::DELETE_WINDOW);
@@ skipping 325 matching lines @@
                                                    ClientWindowId(child_id)));
 }
 
 void WindowTree::RemoveWindowFromParent(uint32_t change_id, Id window_id) {
   bool success = false;
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   DVLOG(3) << "removing window from parent client=" << id_
            << " client window_id= " << window_id << " global window_id="
            << (window ? WindowIdToTransportId(window->id()) : 0);
   if (!window) {
-    DVLOG(1) << "remove failing, invalid window id=" << change_id;
+    DVLOG(1) << "RemoveWindowFromParent failed (invalid window id=" << change_id
+             << ")";
   } else if (!window->parent()) {
-    DVLOG(1) << "remove failing, no parent id=" << change_id;
+    DVLOG(1) << "RemoveWindowFromParent failed (no parent id=" << change_id
+             << ")";
   } else if (!access_policy_->CanRemoveWindowFromParent(window)) {
-    DVLOG(1) << "remove failing, access policy disallowed id=" << change_id;
+    DVLOG(1) << "RemoveWindowFromParent failed (access policy disallowed id="
+             << change_id << ")";
   } else {
     success = true;
     Operation op(this, window_server_,
                  OperationType::REMOVE_WINDOW_FROM_PARENT);
     window->parent()->Remove(window);
   }
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::AddTransientWindow(uint32_t change_id,
@@ skipping 101 matching lines @@
     wm_tree->window_manager_internal_->WmSetBounds(
         wm_change_id, wm_tree->ClientWindowIdForWindow(window).id,
         std::move(bounds));
     return;
   }
 
   DVLOG(3) << "set window bounds client window_id=" << window_id
            << " global window_id="
            << (window ? WindowIdToTransportId(window->id()) : 0)
            << " bounds=" << bounds.ToString();
+
+  if (!window) {
+    DVLOG(1) << "SetWindowBounds failed (invalid window id)";
+    client()->OnChangeCompleted(change_id, false);
+    return;
+  }
+
   // Only the owner of the window can change the bounds.
-  bool success = window && access_policy_->CanSetWindowBounds(window);
+  bool success = access_policy_->CanSetWindowBounds(window);
   if (success) {
     Operation op(this, window_server_, OperationType::SET_WINDOW_BOUNDS);
     window->SetBounds(bounds, local_surface_id);
   } else {
-    DVLOG(1) << "Failed to set bounds on window.";
+    DVLOG(1) << "SetWindowBounds failed (access denied)";
   }
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::SetWindowVisibility(uint32_t change_id,
                                      Id transport_window_id,
                                      bool visible) {
   client()->OnChangeCompleted(
       change_id,
       SetWindowVisibility(ClientWindowId(transport_window_id), visible));
@@ skipping 34 matching lines @@
   client()->OnChangeCompleted(
       change_id, SetWindowOpacity(ClientWindowId(window_id), opacity));
 }
 
 void WindowTree::AttachCompositorFrameSink(
     Id transport_window_id,
     cc::mojom::MojoCompositorFrameSinkRequest compositor_frame_sink,
     cc::mojom::MojoCompositorFrameSinkClientPtr client) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
-  const bool success =
-      window && access_policy_->CanSetWindowCompositorFrameSink(window);
+  if (!window) {
+    DVLOG(1) << "AttachCompositorFrameSink failed (invalid window id)";
+    return;
+  }
+
+  const bool success = access_policy_->CanSetWindowCompositorFrameSink(window);
   if (!success) {
-    DVLOG(1) << "request to AttachCompositorFrameSink failed";
+    DVLOG(1) << "AttachCompositorFrameSink failed (access denied)";
     return;
   }
   window->CreateCompositorFrameSink(std::move(compositor_frame_sink),
                                     std::move(client));
 }
 
 void WindowTree::SetWindowTextInputState(Id transport_window_id,
                                          mojo::TextInputStatePtr state) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
@@ skipping 60 matching lines @@
                                const base::Optional<std::vector<gfx::Rect>>&
                                    transport_additional_client_areas) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   DVLOG(3) << "SetClientArea client window_id=" << transport_window_id
            << " global window_id="
            << (window ? WindowIdToTransportId(window->id()) : 0)
            << " insets=" << insets.top() << " " << insets.left() << " "
            << insets.bottom() << " " << insets.right();
   if (!window) {
-    DVLOG(1) << "SetClientArea failed, no window";
+    DVLOG(1) << "SetClientArea failed (invalid window id)";
     return;
   }
   if (!access_policy_->CanSetClientArea(window)) {
-    DVLOG(1) << "SetClientArea failed, access denied";
+    DVLOG(1) << "SetClientArea failed (access denied)";
     return;
   }
 
   Operation op(this, window_server_, OperationType::SET_CLIENT_AREA);
   window->SetClientArea(insets, transport_additional_client_areas.value_or(
                                     std::vector<gfx::Rect>()));
 }
 
 void WindowTree::SetHitTestMask(Id transport_window_id,
                                 const base::Optional<gfx::Rect>& mask) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
-  if (!window || !access_policy_->CanSetHitTestMask(window)) {
-    DVLOG(1) << "SetHitTestMask failed";
+  if (!window) {
+    DVLOG(1) << "SetHitTestMask failed (invalid window id)";
     return;
   }
 
+  if (!access_policy_->CanSetHitTestMask(window)) {
+    DVLOG(1) << "SetHitTestMask failed (access denied)";
+    return;
+  }
+
   if (mask)
     window->SetHitTestMask(*mask);
   else
     window->ClearHitTestMask();
 }
 
 void WindowTree::SetCanAcceptDrops(Id window_id, bool accepts_drops) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
-  if (!window || !access_policy_->CanSetAcceptDrops(window)) {
-    DVLOG(1) << "SetAcceptsDrops failed";
+  if (!window) {
+    DVLOG(1) << "SetCanAcceptDrops failed (invalid window id)";
     return;
   }
 
+  if (!access_policy_->CanSetAcceptDrops(window)) {
+    DVLOG(1) << "SetAcceptsDrops failed (access denied)";
+    return;
+  }
+
   window->SetCanAcceptDrops(accepts_drops);
 }
 
 void WindowTree::Embed(Id transport_window_id,
                        mojom::WindowTreeClientPtr client,
                        uint32_t flags,
                        const EmbedCallback& callback) {
   callback.Run(
       Embed(ClientWindowId(transport_window_id), std::move(client), flags));
 }
 
 void WindowTree::SetFocus(uint32_t change_id, Id transport_window_id) {
   client()->OnChangeCompleted(change_id,
                               SetFocus(ClientWindowId(transport_window_id)));
 }
 
 void WindowTree::SetCanFocus(Id transport_window_id, bool can_focus) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (!window) {
-    DVLOG(1) << "SetCanFocus failed (invalid id)";
+    DVLOG(1) << "SetCanFocus failed (invalid window id)";
     return;
   }
 
   if (ShouldRouteToWindowManager(window)) {
     WindowManagerDisplayRoot* display_root =
         GetWindowManagerDisplayRoot(window);
     WindowTree* wm_tree = display_root->window_manager_state()->window_tree();
     wm_tree->window_manager_internal_->WmSetCanFocus(transport_window_id,
                                                      can_focus);
   } else if (access_policy_->CanSetFocus(window)) {
     window->set_can_focus(can_focus);
+  } else {
+    DVLOG(1) << "SetCanFocus failed (access denied)";
   }
 }
 
 void WindowTree::SetEventTargetingPolicy(Id transport_window_id,
                                          mojom::EventTargetingPolicy policy) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   // TODO(riajiang): check |event_queue_| is empty for |window|.
   if (window && access_policy_->CanSetEventTargetingPolicy(window))
     window->set_event_targeting_policy(policy);
@@ skipping 193 matching lines @@
     uint32_t drag_operation,
     ui::mojom::PointerKind source) {
   // TODO(erg): SkBitmap is the wrong data type for the drag image; we should
   // be passing ImageSkias once http://crbug.com/655874 is implemented.
 
   ServerWindow* window = GetWindowByClientId(ClientWindowId(source_window_id));
   bool success = window && access_policy_->CanInitiateDragLoop(window);
   if (!success || !ShouldRouteToWindowManager(window)) {
     // We need to fail this move loop change, otherwise the client will just be
     // waiting for |change_id|.
-    DVLOG(1) << "PerformDragDrop failed (access denied).";
+    DVLOG(1) << "PerformDragDrop failed (access denied)";
     client()->OnPerformDragDropCompleted(change_id, false,
                                          mojom::kDropEffectNone);
     return;
   }
 
   WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(window);
   if (!display_root) {
     // The window isn't parented. There's nothing to do.
-    DVLOG(1) << "PerformDragDrop failed (window unparented).";
+    DVLOG(1) << "PerformDragDrop failed (window unparented)";
     client()->OnPerformDragDropCompleted(change_id, false,
                                          mojom::kDropEffectNone);
     return;
   }
 
   if (window_server_->in_move_loop() || window_server_->in_drag_loop()) {
     // Either the window manager is servicing a window drag or we're servicing
     // a drag and drop operation. We can't start a second drag.
-    DVLOG(1) << "PerformDragDrop failed (already performing a drag).";
+    DVLOG(1) << "PerformDragDrop failed (already performing a drag)";
     client()->OnPerformDragDropCompleted(change_id, false,
                                          mojom::kDropEffectNone);
     return;
   }
 
   WindowManagerState* wms = display_root->window_manager_state();
 
   // Send the drag representation to the window manager.
   wms->window_tree()->window_manager_internal_->WmBuildDragImage(
       screen_location, drag_image, drag_image_offset, source);
@@ skipping 34 matching lines @@
 
 void WindowTree::PerformWindowMove(uint32_t change_id,
                                    Id window_id,
                                    ui::mojom::MoveLoopSource source,
                                    const gfx::Point& cursor) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   bool success = window && access_policy_->CanInitiateMoveLoop(window);
   if (!success || !ShouldRouteToWindowManager(window)) {
     // We need to fail this move loop change, otherwise the client will just be
     // waiting for |change_id|.
-    DVLOG(1) << "PerformWindowMove failed (access denied).";
+    DVLOG(1) << "PerformWindowMove failed (access denied)";
     OnChangeCompleted(change_id, false);
     return;
   }
 
   WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(window);
   if (!display_root) {
     // The window isn't parented. There's nothing to do.
-    DVLOG(1) << "PerformWindowMove failed (window unparented).";
+    DVLOG(1) << "PerformWindowMove failed (window unparented)";
     OnChangeCompleted(change_id, false);
     return;
   }
 
   if (window_server_->in_move_loop() || window_server_->in_drag_loop()) {
     // Either the window manager is servicing a window drag or we're servicing
     // a drag and drop operation. We can't start a second drag.
-    DVLOG(1) << "PerformWindowMove failed (already performing a drag).";
+    DVLOG(1) << "PerformWindowMove failed (already performing a drag)";
     OnChangeCompleted(change_id, false);
     return;
   }
 
   // When we perform a window move loop, we give the window manager non client
   // capture. Because of how the capture public interface currently works,
   // SetCapture() will check whether the mouse cursor is currently in the
   // non-client area and if so, will redirect messages to the window
   // manager. (And normal window movement relies on this behaviour.)
   WindowManagerState* wms = display_root->window_manager_state();
   wms->SetCapture(window, wms->window_tree()->id());
 
   const uint32_t wm_change_id =
       window_server_->GenerateWindowManagerChangeId(this, change_id);
   window_server_->StartMoveLoop(wm_change_id, window, this, window->bounds());
   wms->window_tree()->window_manager_internal_->WmPerformMoveLoop(
       wm_change_id, wms->window_tree()->ClientWindowIdForWindow(window).id,
       source, cursor);
 }
 
 void WindowTree::CancelWindowMove(Id window_id) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
-  bool success = window && access_policy_->CanInitiateMoveLoop(window);
-  if (!success) {
-    DVLOG(1) << "CancelWindowMove failed (no window / access denied)";
+  if (!window) {
+    DVLOG(1) << "CancelWindowMove failed (invalid window id)";
     return;
   }
 
+  bool success = access_policy_->CanInitiateMoveLoop(window);
+  if (!success) {
+    DVLOG(1) << "CancelWindowMove failed (access denied)";
+    return;
+  }
+
   if (window != window_server_->GetCurrentMoveLoopWindow()) {
     DVLOG(1) << "CancelWindowMove failed (not the move loop window)";
     return;
   }
 
   if (window_server_->GetCurrentMoveLoopInitiator() != this) {
     DVLOG(1) << "CancelWindowMove failed (not the move loop initiator)";
     return;
   }
 
@@ skipping 26 matching lines @@
   window_manager_state_->event_dispatcher()->RemoveAccelerator(id);
 }
 
 void WindowTree::AddActivationParent(Id transport_window_id) {
   AddActivationParent(ClientWindowId(transport_window_id));
 }
 
 void WindowTree::RemoveActivationParent(Id transport_window_id) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
-  if (window) {
-    Display* display = GetDisplay(window);
-    if (display)
-      display->RemoveActivationParent(window);
-    else
-      DVLOG(1) << "RemoveActivationParent window not associated with display";
-  } else {
-    DVLOG(1) << "RemoveActivationParent supplied invalid window id";
+  if (!window) {
+    DVLOG(1) << "RemoveActivationParent failed (invalid window id)";
+    return;
   }
+
+  Display* display = GetDisplay(window);
+  if (!display) {
+    DVLOG(1) << "RemoveActivationParent window not associated with display";
+    return;
+  }
+
+  display->RemoveActivationParent(window);
 }
 
 void WindowTree::ActivateNextWindow() {
   DCHECK(window_manager_state_);
   if (window_server_->user_id_tracker()->active_id() != user_id_)
     return;
 
   ServerWindow* focused_window = window_server_->GetFocusedWindow();
   if (focused_window) {
     WindowManagerDisplayRoot* display_root =
@@ skipping 10 matching lines @@
   if (displays.empty())
     return;
 
   (*displays.begin())->ActivateNextWindow();
 }
 
 void WindowTree::SetExtendedHitArea(Id window_id, const gfx::Insets& hit_area) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   // Extended hit test region should only be set by the owner of the window.
   if (!window) {
-    DVLOG(1) << "SetExtendedHitArea supplied unknown window";
+    DVLOG(1) << "SetExtendedHitArea failed (invalid window id)";
     return;
   }
   if (window->id().client_id != id_) {
-    DVLOG(1) << "SetExtendedHitArea supplied window that client does not own";
+    DVLOG(1) << "SetExtendedHitArea failed (supplied window that client does "
+             << "not own)";
     return;
   }
   window->set_extended_hit_test_region(hit_area);
 }
 
 void WindowTree::SetDisplayRoot(const display::Display& display,
                                 mojom::WmViewportMetricsPtr viewport_metrics,
                                 bool is_primary_display,
                                 Id window_id,
                                 const SetDisplayRootCallback& callback) {
@@ skipping 59 matching lines @@
 void WindowTree::WmSetFrameDecorationValues(
     mojom::FrameDecorationValuesPtr values) {
   DCHECK(window_manager_state_);
   window_manager_state_->SetFrameDecorationValues(std::move(values));
 }
 
 void WindowTree::WmSetNonClientCursor(uint32_t window_id,
                                       ui::CursorData cursor) {
   DCHECK(window_manager_state_);
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
-  if (window) {
-    window->SetNonClientCursor(std::move(cursor));
-  } else {
-    DVLOG(1) << "trying to update non-client cursor of invalid window";
+  if (!window) {
+    DVLOG(1) << "WmSetNonClientCursor failed (invalid window id)";
+    return;
   }
+
+  window->SetNonClientCursor(std::move(cursor));
 }
 
 void WindowTree::OnWmCreatedTopLevelWindow(uint32_t change_id,
                                            Id transport_window_id) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (window && window->id().client_id != id_) {
-    DVLOG(1) << "OnWmCreatedTopLevelWindow supplied invalid window id";
+    DVLOG(1) << "OnWmCreatedTopLevelWindow failed (invalid window id)";
     window_server_->WindowManagerSentBogusMessage();
     window = nullptr;
   }
   if (window) {
     client()->OnFrameSinkIdAllocated(transport_window_id,
                                      window->frame_sink_id());
   }
   window_server_->WindowManagerCreatedTopLevelWindow(this, change_id, window);
 }
 
 void WindowTree::OnAcceleratorAck(uint32_t event_id,
                                   mojom::EventResult result,
                                   const EventProperties& properties) {
   DVLOG(3) << "OnAcceleratorAck client=" << id_;
   if (event_ack_id_ == 0 || event_id != event_ack_id_ ||
       !accelerator_ack_callback_) {
-    DVLOG(1) << "OnAcceleratorAck supplied invalid event_id";
+    DVLOG(1) << "OnAcceleratorAck failed (invalid event id)";
     window_server_->WindowManagerSentBogusMessage();
     return;
   }
   event_ack_id_ = 0;
   DCHECK(window_manager_state_);
   base::ResetAndReturn(&accelerator_ack_callback_).Run(result, properties);
 }
 
 bool WindowTree::HasRootForAccessPolicy(const ServerWindow* window) const {
   return HasRoot(window);
@@ skipping 140 matching lines @@
   client()->OnCompleteDrop(client_window_id.id, event_flags, cursor_offset,
                            effect_bitmask, callback);
 }
 
 void WindowTree::PerformOnDragDropDone() {
   client()->OnDragDropDone();
 }
 
 }  // namespace ws
 }  // namespace ui