Enable the MojoDOMSTorageBrowserTests

services/shell/shell.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/shell/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 104 matching lines @@
                         public mojom::Shell {
  public:
   Instance(shell::Shell* shell,
            const Identity& identity,
            const CapabilitySpec& capability_spec)
       : shell_(shell),
         id_(GenerateUniqueID()),
         identity_(identity),
         capability_spec_(capability_spec),
         allow_any_application_(capability_spec.required.count("*") == 1),
-        pid_receiver_binding_(this) {
+        pid_receiver_binding_(this),
+        weak_factory_(this) {
     if (identity_.name() == kShellName || identity_.name() == kCatalogName)
       pid_ = base::Process::Current().Pid();
     DCHECK_NE(mojom::kInvalidInstanceID, id_);
   }
 
   ~Instance() override {
     if (parent_)
       parent_->RemoveChild(this);
     // |children_| will be modified during destruction.
     std::set<Instance*> children = children_;
@@ skipping 73 matching lines @@
         std::move(client_process_connection->shell_client), 0));
     pid_receiver_binding_.Bind(
         std::move(client_process_connection->pid_receiver_request));
     StartWithClient(std::move(client));
   }
 
   void StartWithFilePath(const base::FilePath& path) {
     CHECK(!shell_client_);
     runner_ = shell_->native_runner_factory_->Create(path);
     bool start_sandboxed = false;
-    // We own |runner_|, so Unretained is safe here.

[michaeln, 2016/05/06 22:12:42]

The InProcessNativeRunner wraps the OnRunnerComplete callback like this..

  DCHECK(app_completed_callback_runner_.is_null());
  app_completed_callback_runner_ = base::Bind(
      &base::TaskRunner::PostTask, base::ThreadTaskRunnerHandle::Get(),
      FROM_HERE, app_completed_callback);

so there's no guarantee |this| instance is not deleted at the time the callback
is run.

Idk if calling thru a weakptr is the best option but it does avoid the crash.
There are other Unretained instance ptrs in this class, i could switch them all
over to the weakptr if you like.

Alternatively, I could change InProcessNativeRunner to not call the
RunnerComplete callback after it has been deleted.

     mojom::ShellClientPtr client = runner_->Start(
         path, identity_, start_sandboxed,
-        base::Bind(&Instance::PIDAvailable, base::Unretained(this)),
-        base::Bind(&Instance::OnRunnerCompleted, base::Unretained(this)));
+        base::Bind(&Instance::PIDAvailable, weak_factory_.GetWeakPtr()),
+        base::Bind(&Instance::OnRunnerCompleted, weak_factory_.GetWeakPtr()));
     StartWithClient(std::move(client));
   }
 
   mojom::InstanceInfoPtr CreateInstanceInfo() const {
     mojom::InstanceInfoPtr info(mojom::InstanceInfo::New());
     info->id = id_;
     info->identity = mojom::Identity::From(identity_);
     info->pid = pid_;
     return info;
   }
@@ skipping 213 matching lines @@
   const CapabilitySpec capability_spec_;
   const bool allow_any_application_;
   std::unique_ptr<NativeRunner> runner_;
   mojom::ShellClientPtr shell_client_;
   mojo::Binding<mojom::PIDReceiver> pid_receiver_binding_;
   mojo::BindingSet<mojom::Connector> connectors_;
   mojo::BindingSet<mojom::Shell> shell_bindings_;
   base::ProcessId pid_ = base::kNullProcessId;
   Instance* parent_ = nullptr;
   std::set<Instance*> children_;
+  base::WeakPtrFactory<Instance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
 // static
 Shell::TestAPI::TestAPI(Shell* shell) : shell_(shell) {}
 Shell::TestAPI::~TestAPI() {}
 
 bool Shell::TestAPI::HasRunningInstanceForName(const std::string& name) const {
   for (const auto& entry : shell_->identity_to_instance_) {
@@ skipping 315 matching lines @@
 
   // Now that the instance has a ShellClient, we can connect to it.
   instance->ConnectToClient(std::move(params));
 }
 
 base::WeakPtr<Shell> Shell::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace shell