Adds some TODOs with references to bugs

ui/views/mus/mus_client.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 "ui/views/mus/mus_client.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "services/service_manager/public/cpp/connection.h"
 #include "services/service_manager/public/cpp/connector.h"
@@ skipping 12 matching lines @@
 #include "ui/views/mus/desktop_window_tree_host_mus.h"
 #include "ui/views/mus/screen_mus.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/wm/core/capture_controller.h"
 #include "ui/wm/core/wm_state.h"
 
 namespace views {
 namespace {
 
+// TODO: property converter should likely live in aura as it needs to be used
+// by both ash and views. http://crbug.com/663522.
 class PropertyConverterImpl : public aura::PropertyConverter {
  public:
   PropertyConverterImpl() {}
   ~PropertyConverterImpl() override {}
 
   // aura::PropertyConverter:
   bool ConvertPropertyForTransport(
       aura::Window* window,
       const void* key,
       std::string* transport_name,
@@ skipping 67 matching lines @@
 
   gpu_service_ = aura::GpuService::Create(connector, std::move(io_task_runner));
   compositor_context_factory_ =
       base::MakeUnique<aura::MusContextFactory>(gpu_service_.get());
   aura::Env::GetInstance()->set_context_factory(
       compositor_context_factory_.get());
   window_tree_client_ =
       base::MakeUnique<aura::WindowTreeClient>(this, nullptr, nullptr);
   window_tree_client_->ConnectViaWindowTreeFactory(connector_);
 
-  // TODO(sky): wire up PointerWatcherEventRouter.
+  // TODO: wire up PointerWatcherEventRouter. http://crbug.com/663526.
 
   screen_ = base::MakeUnique<ScreenMus>(this);
   screen_->Init(connector);
 
   std::unique_ptr<ClipboardMus> clipboard = base::MakeUnique<ClipboardMus>();
   clipboard->Init(connector);
   ui::Clipboard::SetClipboardForCurrentThread(std::move(clipboard));
 
   ui::OSExchangeDataProviderFactory::SetFactory(this);
 
   ViewsDelegate::GetInstance()->set_native_widget_factory(
       base::Bind(&MusClient::CreateNativeWidget, base::Unretained(this)));
 }
 
 void MusClient::OnEmbed(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host) {
   NOTREACHED();
 }
 
 void MusClient::OnLostConnection(aura::WindowTreeClient* client) {}
 
 void MusClient::OnEmbedRootDestroyed(aura::Window* root) {
   // Not called for MusClient as WindowTreeClient isn't created by
   // way of an Embed().
   NOTREACHED();
 }
 
 void MusClient::OnPointerEventObserved(const ui::PointerEvent& event,
                                        aura::Window* target) {
-  // TODO(sky): wire up pointer events.
+  // TODO: wire up PointerWatcherEventRouter. http://crbug.com/663526.
   NOTIMPLEMENTED();
 }
 
 void MusClient::OnWindowManagerFrameValuesChanged() {
-  // TODO(sky): wire up to DesktopNativeWidgetAura.
+  // TODO: wire up client area. http://crbug.com/663525.
   NOTIMPLEMENTED();
 }
 
 aura::client::CaptureClient* MusClient::GetCaptureClient() {
   return wm::CaptureController::Get();
 }
 
 aura::PropertyConverter* MusClient::GetPropertyConverter() {
   return property_converter_.get();
 }
 
 gfx::Point MusClient::GetCursorScreenPoint() {
   return window_tree_client_->GetCursorScreenPoint();
 }
 
 aura::Window* MusClient::GetWindowAtScreenPoint(const gfx::Point& point) {
   for (aura::Window* root : window_tree_client_->GetRoots()) {
     aura::WindowTreeHost* window_tree_host = root->GetHost();
     if (!window_tree_host)
       continue;
-    // TODO: this likely gets z-order wrong.
+    // TODO: this likely gets z-order wrong. http://crbug.com/663606.
     gfx::Point relative_point(point);
     window_tree_host->ConvertPointFromNativeScreen(&relative_point);
     if (gfx::Rect(root->bounds().size()).Contains(relative_point))
       return root->GetTopWindowContainingPoint(relative_point);
   }
   return nullptr;
 }
 
 std::unique_ptr<OSExchangeData::Provider> MusClient::BuildProvider() {
   return base::MakeUnique<aura::OSExchangeDataProviderMus>();
 }
 
 }  // namespace views