Avoid two targeting phases in aura client-lib and EventProcessor.

ui/aura/window_tree_host.cc

 // Copyright (c) 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 "ui/aura/window_tree_host.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
@@ skipping 242 matching lines @@
       Env::GetInstance()->context_factory_private();
   compositor_.reset(new ui::Compositor(
       frame_sink_id.is_valid() ? frame_sink_id
                                : context_factory_private->AllocateFrameSinkId(),
       context_factory, context_factory_private,
       base::ThreadTaskRunnerHandle::Get()));
   if (!dispatcher()) {
     window()->Init(ui::LAYER_NOT_DRAWN);
     window()->set_host(this);
     window()->SetName("RootWindow");
-    window()->SetEventTargeter(
-        std::unique_ptr<ui::EventTargeter>(new WindowTargeter()));
+    if (Env::GetInstance()->mode() == Env::Mode::LOCAL) {

[sky, 2017/02/15 20:47:17]

Is it possible to remove this code and change Env to always create a
WindowTargeter?

[riajiang, 2017/02/16 00:34:08]

We are only creating a targeter for the root window in non-mus mode here because
we wanted to avoid walking all the way up to the root window just to use this
default event targeter when we try to find the farthest ancestor with a targeter
set in WindowEventDispatcher::GetRootForEvent. WDYT?

[sky, 2017/02/16 01:03:02]

The walking only happens in the mus case though, and I'm referring to the local
case. Maybe I missing something? What tree walking are you referring to?

Correct me if I'm wrong, but if you remove this code, and you make
WindowEventDispatcher always create the event_targeter_, then isn't that the
only changes that are needed? The local case won't do the tree walking as you
have it now.

[riajiang, 2017/02/16 19:10:35]

Oh I see, thanks for clarifying! You mean also getting the default targeter from
WindowEventDispatcher in EventProcessor for local case? I removed the code here
and changed WindowEventDispatcher to always create the targeter; EventProcessor
will then get the default targeter for the local case as well.

+      window()->SetEventTargeter(
+          std::unique_ptr<ui::EventTargeter>(new WindowTargeter()));
+    }
     dispatcher_.reset(new WindowEventDispatcher(this));
   }
 }
 
 void WindowTreeHost::InitCompositor() {
   compositor_->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(window()),
                                GetBoundsInPixels().size());
   compositor_->SetRootLayer(window()->layer());
   compositor_->SetDisplayColorSpace(
       GetICCProfileForCurrentDisplay().GetColorSpace());
@@ skipping 72 matching lines @@
   client::CursorClient* cursor_client = client::GetCursorClient(window());
   if (cursor_client) {
     const display::Display& display =
         display::Screen::GetScreen()->GetDisplayNearestWindow(window());
     cursor_client->SetDisplay(display);
   }
   dispatcher()->OnCursorMovedToRootLocation(root_location);
 }
 
 }  // namespace aura