add ash_resources.grd and necessary changes to use images in ash/resources

ash/display/multi_display_manager.cc

 // Copyright (c) 2012 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 "ash/display/multi_display_manager.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/display/display_controller.h"
@@ skipping 60 matching lines @@
       aura::Env::GetInstance()->display_manager());
   manager->ScaleDisplayImpl();
 }
 
 void MultiDisplayManager::InitInternalDisplayInfo() {
 #if defined(OS_CHROMEOS)
   if (!base::chromeos::IsRunningOnChromeOS())
     return;
   std::vector<XID> outputs;
   ui::GetOutputDeviceHandles(&outputs);
-  std::vector<std::string> output_names = ui::GetOutputNames(outputs);
-  for (size_t i = 0; i < output_names.size(); ++i) {
+  // Output names are hardware specific and never changes.
+  output_names_ = ui::GetOutputNames(outputs);
+  for (size_t i = 0; i < output_names_.size(); ++i) {
     if (chromeos::OutputConfigurator::IsInternalOutputName(
-            output_names[i])) {
+            output_names_[i])) {
+      // Set internal as primary by default. This may be
+      // overritten by settings later.
+      primary_output_name_ = output_names_[i];
       XID internal_output = outputs[i];
       uint16 manufacturer_id = 0;
       uint32 serial_number = 0;
       ui::GetOutputDeviceData(
           internal_output, &manufacturer_id, &serial_number, NULL);
       internal_display_id_ =
           gfx::Display::GetID(manufacturer_id, serial_number);
       return;
     }
   }
 #endif
 }
 
+void MultiDisplayManager::SetOutputNameForPrimaryDisplay(
+    const std::string& name) {
+  primary_output_name_ = name;
+  std::vector<gfx::Display> update = displays_;
+  OnNativeDisplaysChanged(displays_);
+}
+
 bool MultiDisplayManager::HasInternalDisplay() const {
   return internal_display_id_ != gfx::Display::kInvalidDisplayID;
 }
 
 bool MultiDisplayManager::UpdateWorkAreaOfDisplayNearestWindow(
     const aura::Window* window,
     const gfx::Insets& insets) {
   const RootWindow* root = window->GetRootWindow();
   gfx::Display& display = FindDisplayForRootWindow(root);
   gfx::Rect old_work_area = display.work_area();
@@ skipping 41 matching lines @@
       }
     }
     // If the internal display wasn't connected, use the cached value.
     if (!internal_display_connected)
       new_displays.push_back(*internal_display_.get());
     new_displays.insert(
         new_displays.end(), updated_displays.begin(), updated_displays.end());
   } else {
     new_displays = updated_displays;
   }
+  // Move the primary display to the first if any.
+  MovePrimaryToFirst();
 
   size_t min = std::min(displays_.size(), new_displays.size());
 
   // TODO(oshima): Fix this so that we can differentiate outputs
   // and keep a content on one display stays on the same display
   // when a display is added or removed.
   for (size_t i = 0; i < min; ++i) {
     gfx::Display& current_display = displays_[i];
     const gfx::Display& new_display = new_displays[i];
     if (current_display.bounds_in_pixel() != new_display.bounds_in_pixel() ||
@@ skipping 192 matching lines @@
 int64 MultiDisplayManager::EnableInternalDisplayForTest() {
   const int64 kInternalDisplayIdForTest = 9999;
   internal_display_id_ = kInternalDisplayIdForTest;
   internal_display_.reset(new gfx::Display(internal_display_id_,
                                            gfx::Rect(800, 600)));
   return kInternalDisplayIdForTest;
 }
 
 }  // namespace internal
 }  // namespace ash