diff --git a/src/demo-app/demo-app-module.ts b/src/demo-app/demo-app-module.ts
index 5f4a02dc5f68..0021888b8355 100644
--- a/src/demo-app/demo-app-module.ts
+++ b/src/demo-app/demo-app-module.ts
@@ -34,6 +34,7 @@ import {PortalDemo, ScienceJoke} from './portal/portal-demo';
 import {MenuDemo} from './menu/menu-demo';
 import {TabsDemo, SunnyTabContent, RainyTabContent, FoggyTabContent} from './tabs/tabs-demo';
 import {ProjectionDemo, ProjectionTestComponent} from './projection/projection-demo';
+import {PlatformDemo} from './platform/platform-demo';
 
 @NgModule({
   imports: [
@@ -84,6 +85,7 @@ import {ProjectionDemo, ProjectionTestComponent} from './projection/projection-d
     SunnyTabContent,
     RainyTabContent,
     FoggyTabContent,
+    PlatformDemo
   ],
   entryComponents: [
     DemoApp,
diff --git a/src/demo-app/demo-app/demo-app.ts b/src/demo-app/demo-app/demo-app.ts
index ae2ab491bdf6..9910a5c5d505 100644
--- a/src/demo-app/demo-app/demo-app.ts
+++ b/src/demo-app/demo-app/demo-app.ts
@@ -46,6 +46,7 @@ export class DemoApp {
     {name: 'Snack Bar', route: 'snack-bar'},
     {name: 'Tabs', route: 'tabs'},
     {name: 'Toolbar', route: 'toolbar'},
-    {name: 'Tooltip', route: 'tooltip'}
+    {name: 'Tooltip', route: 'tooltip'},
+    {name: 'Platform', route: 'platform'}
   ];
 }
diff --git a/src/demo-app/demo-app/routes.ts b/src/demo-app/demo-app/routes.ts
index f2e1cf7b68e9..a92e1acd40e2 100644
--- a/src/demo-app/demo-app/routes.ts
+++ b/src/demo-app/demo-app/routes.ts
@@ -29,6 +29,7 @@ import {TooltipDemo} from '../tooltip/tooltip-demo';
 import {SnackBarDemo} from '../snack-bar/snack-bar-demo';
 import {ProjectionDemo} from '../projection/projection-demo';
 import {TABS_DEMO_ROUTES} from '../tabs/routes';
+import {PlatformDemo} from '../platform/platform-demo';
 
 export const DEMO_APP_ROUTES: Routes = [
   {path: '', component: Home},
@@ -60,4 +61,5 @@ export const DEMO_APP_ROUTES: Routes = [
   {path: 'dialog', component: DialogDemo},
   {path: 'tooltip', component: TooltipDemo},
   {path: 'snack-bar', component: SnackBarDemo},
+  {path: 'platform', component: PlatformDemo}
 ];
diff --git a/src/demo-app/platform/platform-demo.ts b/src/demo-app/platform/platform-demo.ts
new file mode 100644
index 000000000000..45283f04fc83
--- /dev/null
+++ b/src/demo-app/platform/platform-demo.ts
@@ -0,0 +1,19 @@
+import {Component} from '@angular/core';
+import {MdPlatform} from '@angular/material';
+
+@Component({
+  template: `
+    <p>Is Android: {{ platform.ANDROID }}</p>
+    <p>Is iOS: {{ platform.IOS }}</p>
+    <p>Is Firefox: {{ platform.FIREFOX }}</p>
+    <p>Is Blink: {{ platform.BLINK }}</p>
+    <p>Is Webkit: {{ platform.WEBKIT }}</p>
+    <p>Is Trident: {{ platform.TRIDENT }}</p>
+
+  `
+})
+export class PlatformDemo {
+
+  constructor(public platform: MdPlatform) {}
+
+}
diff --git a/src/lib/core/a11y/focus-trap.spec.ts b/src/lib/core/a11y/focus-trap.spec.ts
index e4c6a7d0458e..c262e1f01df5 100644
--- a/src/lib/core/a11y/focus-trap.spec.ts
+++ b/src/lib/core/a11y/focus-trap.spec.ts
@@ -3,6 +3,7 @@ import {By} from '@angular/platform-browser';
 import {Component} from '@angular/core';
 import {FocusTrap} from './focus-trap';
 import {InteractivityChecker} from './interactivity-checker';
+import {MdPlatform} from '../platform/platform';
 
 
 describe('FocusTrap', () => {
@@ -12,7 +13,7 @@ describe('FocusTrap', () => {
 
     beforeEach(() => TestBed.configureTestingModule({
       declarations: [FocusTrap, FocusTrapTestApp],
-      providers: [InteractivityChecker]
+      providers: [InteractivityChecker, MdPlatform]
     }));
 
     beforeEach(inject([InteractivityChecker], (c: InteractivityChecker) => {
@@ -45,7 +46,7 @@ describe('FocusTrap', () => {
 
     beforeEach(() => TestBed.configureTestingModule({
       declarations: [FocusTrap, FocusTrapTargetTestApp],
-      providers: [InteractivityChecker]
+      providers: [InteractivityChecker, MdPlatform]
     }));
 
     beforeEach(inject([InteractivityChecker], (c: InteractivityChecker) => {
diff --git a/src/lib/core/a11y/index.ts b/src/lib/core/a11y/index.ts
index 70621bb45e90..0e285f77d60c 100644
--- a/src/lib/core/a11y/index.ts
+++ b/src/lib/core/a11y/index.ts
@@ -2,10 +2,12 @@ import {NgModule, ModuleWithProviders} from '@angular/core';
 import {FocusTrap} from './focus-trap';
 import {MdLiveAnnouncer} from './live-announcer';
 import {InteractivityChecker} from './interactivity-checker';
+import {PlatformModule} from '../platform/platform';
 
 export const A11Y_PROVIDERS = [MdLiveAnnouncer, InteractivityChecker];
 
 @NgModule({
+  imports: [PlatformModule],
   declarations: [FocusTrap],
   exports: [FocusTrap],
 })
diff --git a/src/lib/core/a11y/interactivity-checker.spec.ts b/src/lib/core/a11y/interactivity-checker.spec.ts
index 648499781aef..2a7e0cdaa8b7 100644
--- a/src/lib/core/a11y/interactivity-checker.spec.ts
+++ b/src/lib/core/a11y/interactivity-checker.spec.ts
@@ -1,14 +1,18 @@
 import {InteractivityChecker} from './interactivity-checker';
+import {MdPlatform} from '../platform/platform';
+import {async} from '@angular/core/testing';
 
 describe('InteractivityChecker', () => {
   let testContainerElement: HTMLElement;
   let checker: InteractivityChecker;
+  let platform: MdPlatform;
 
   beforeEach(() => {
     testContainerElement = document.createElement('div');
     document.body.appendChild(testContainerElement);
 
-    checker = new InteractivityChecker();
+    platform = new MdPlatform();
+    checker = new InteractivityChecker(platform);
   });
 
   afterEach(() => {
@@ -280,6 +284,178 @@ describe('InteractivityChecker', () => {
             .toBe(true, `Expected <${el.nodeName} tabindex="0"> to be tabbable`);
       });
     });
+
+    it('should respect the inherited tabindex inside of frame elements', () => {
+      let iframe = createFromTemplate('<iframe>', true) as HTMLFrameElement;
+      let button = createFromTemplate('<button tabindex="0">Not Tabbable</button>');
+
+      appendElements([iframe]);
+
+      iframe.tabIndex = -1;
+      iframe.contentDocument.body.appendChild(button);
+
+      expect(checker.isTabbable(iframe)).toBe(false);
+      expect(checker.isTabbable(button)).toBe(false);
+
+      iframe.tabIndex = null;
+
+      expect(checker.isTabbable(iframe)).toBe(false);
+      expect(checker.isTabbable(button)).toBe(true);
+    });
+
+    it('should not mark elements inside of object frames as tabbable (BLINK & WEBKIT)', () => {
+      platform.BLINK = true;
+
+      let objectEl = createFromTemplate('<object>', true) as HTMLObjectElement;
+      let button = createFromTemplate('<button tabindex="0">Not Tabbable</button>');
+
+      appendElements([objectEl]);
+
+      // This is a hack to create an empty contentDocument for the frame element.
+      objectEl.type = 'text/html';
+      objectEl.contentDocument.body.appendChild(button);
+
+      expect(checker.isTabbable(objectEl)).toBe(false);
+      expect(checker.isTabbable(button)).toBe(false);
+    });
+
+    it('should not mark elements inside of invisible frames as tabbable (BLINK & WEBKIT)', () => {
+      let iframe = createFromTemplate('<iframe>', true) as HTMLFrameElement;
+      let button = createFromTemplate('<button tabindex="0">Not Tabbable</button>');
+
+      appendElements([iframe]);
+
+      iframe.style.display = 'none';
+      iframe.contentDocument.body.appendChild(button);
+
+      expect(checker.isTabbable(iframe)).toBe(false);
+      expect(checker.isTabbable(button)).toBe(false);
+    });
+
+    it('should mark elements which are contentEditable as tabbable', async(() => {
+      let editableEl = createFromTemplate('<div contenteditable="true">', true);
+
+      // Wait one tick, because the browser takes some time to update the tabIndex
+      // according to the contentEditable attribute.
+      setTimeout(() => {
+
+        expect(checker.isTabbable(editableEl)).toBe(true);
+
+        editableEl.tabIndex = -1;
+
+        expect(checker.isTabbable(editableEl)).toBe(false);
+
+      }, 1);
+
+    }));
+
+    it('should never mark iframe elements as tabbable', () => {
+      let iframe = createFromTemplate('<iframe>', true);
+
+      // iFrame elements will be never marked as tabbable, because it depends on the content
+      // which is mostly not detectable due to CORS and also the checks will be not reliable.
+      expect(checker.isTabbable(iframe)).toBe(false);
+    });
+
+    it('should never mark object frame elements as tabbable', () => {
+      let objectEl = createFromTemplate('<object>', true);
+
+      expect(checker.isTabbable(objectEl)).toBe(false);
+    });
+
+    it('should always mark audio elements without controls as not tabbable', () => {
+      let audio = createFromTemplate('<audio>', true);
+
+      expect(checker.isTabbable(audio)).toBe(false);
+    });
+
+    it('should always mark audio elements with controls as tabbable (BLINK)', () => {
+      platform.BLINK = true;
+
+      let audio = createFromTemplate('<audio controls>', true);
+
+      expect(checker.isTabbable(audio)).toBe(true);
+
+      audio.tabIndex = -1;
+
+      // The audio element will be still tabbable because Blink always
+      // considers them as tabbable.
+      expect(checker.isTabbable(audio)).toBe(true);
+
+      platform.BLINK = false;
+
+      expect(checker.isTabbable(audio)).toBe(false);
+    });
+
+    it('should never mark video elements without controls as tabbable (IE11)', () => {
+      platform.TRIDENT = true;
+
+      let video = createFromTemplate('<video>', true);
+
+      expect(checker.isTabbable(video)).toBe(false);
+    });
+
+    it('should always mark video elements with controls as tabbable (BLINK & FIREFOX)', () => {
+      platform.BLINK = true;
+
+      let video = createFromTemplate('<video controls>', true);
+
+      expect(checker.isTabbable(video)).toBe(true);
+
+      video.tabIndex = -1;
+
+      expect(checker.isTabbable(video)).toBe(true);
+    });
+
+    it('should respect the tabindex for video elements with controls', () => {
+      // Don't run the test as Blink or Firefox, because those will always mark
+      // video elements with controls as tabbable.
+      platform.BLINK = false;
+      platform.FIREFOX = false;
+
+      let video = createFromTemplate('<video controls>', true);
+
+      expect(checker.isTabbable(video)).toBe(true);
+
+      video.tabIndex = -1;
+
+      expect(checker.isTabbable(video)).toBe(false);
+    });
+
+    describe('for iOS browsers', () => {
+
+      beforeEach(() => {
+        platform.IOS = true;
+        platform.WEBKIT = true;
+      });
+
+      it('should never allow div elements to be tabbable', () => {
+        let divEl = createFromTemplate('<div tabindex="0">', true);
+
+        expect(checker.isTabbable(divEl)).toBe(false);
+      });
+
+      it('should never allow span elements to be tabbable', () => {
+        let spanEl = createFromTemplate('<span tabindex="0">Text</span>', true);
+
+        expect(checker.isTabbable(spanEl)).toBe(false);
+      });
+
+      it('should never allow button elements to be tabbable', () => {
+        let buttonEl = createFromTemplate('<button tabindex="0">', true);
+
+        expect(checker.isTabbable(buttonEl)).toBe(false);
+      });
+
+      it('should never allow anchor elements to be tabbable', () => {
+        let anchorEl = createFromTemplate('<a tabindex="0">Link</a>', true);
+
+        expect(checker.isTabbable(anchorEl)).toBe(false);
+      });
+
+    });
+
+
   });
 
   /** Creates an array of elements with the given node names. */
@@ -287,6 +463,21 @@ describe('InteractivityChecker', () => {
     return nodeNames.map(name => document.createElement(name));
   }
 
+  function createFromTemplate(template: string, append = false) {
+    let tmpRoot = document.createElement('div');
+    tmpRoot.innerHTML = template;
+
+    let element = tmpRoot.firstElementChild;
+
+    tmpRoot.removeChild(element);
+
+    if (append) {
+      appendElements([element]);
+    }
+
+    return element as HTMLElement;
+  }
+
   /** Appends elements to the testContainerElement. */
   function appendElements(elements: Element[]) {
     for (let e of elements) {
diff --git a/src/lib/core/a11y/interactivity-checker.ts b/src/lib/core/a11y/interactivity-checker.ts
index 91f7c29c2c59..34dcd62d5561 100644
--- a/src/lib/core/a11y/interactivity-checker.ts
+++ b/src/lib/core/a11y/interactivity-checker.ts
@@ -1,4 +1,5 @@
 import {Injectable} from '@angular/core';
+import {MdPlatform} from '../platform/platform';
 
 /**
  * Utility for checking the interactivity of an element, such as whether is is focusable or
@@ -16,6 +17,8 @@ import {Injectable} from '@angular/core';
 @Injectable()
 export class InteractivityChecker {
 
+  constructor(private platform: MdPlatform) {}
+
   /** Gets whether an element is disabled. */
   isDisabled(element: HTMLElement) {
     // This does not capture some cases, such as a non-form control with a disabled attribute or
@@ -30,18 +33,21 @@ export class InteractivityChecker {
    * being clipped by an `overflow: hidden` parent or being outside the viewport.
    */
   isVisible(element: HTMLElement) {
-    // There are additional special cases that this does not capture, but this will work for
-    // the most common cases.
+    let nodeName = element.nodeName.toLowerCase();
+    let isControlAudio = nodeName === 'audio' && (element as HTMLAudioElement).controls;
 
-    // Use logic from jQuery to check for `display: none`.
-    // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12
-    if (!(element.offsetWidth || element.offsetHeight || element.getClientRects().length)) {
+    // In IE11 audio elements with controls have invalid rectangles, but are still visible.
+    if (!isControlAudio && !checkRectangles()) {
       return false;
     }
 
-    // Check for css `visibility` property.
-    // TODO(jelbourn): do any browsers we support return an empty string instead of 'visible'?
-    return getComputedStyle(element).getPropertyValue('visibility') == 'visible';
+    return getComputedStyle(element).getPropertyValue('visibility') === 'visible';
+
+    function checkRectangles() {
+      // Use logic from jQuery to check for an invisible element.
+      // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12
+      return element.offsetWidth || element.offsetHeight || element.getClientRects().length;
+    }
   }
 
   /**
@@ -49,8 +55,72 @@ export class InteractivityChecker {
    * Assumes that the element has already been checked with isFocusable.
    */
   isTabbable(element: HTMLElement) {
-    // Again, naive approach that does not capture many special cases and browser quirks.
-    return element.tabIndex >= 0;
+
+    let nodeName = element.nodeName.toLowerCase();
+    let frameElement = getWindow(element).frameElement as HTMLElement;
+    let frameType = frameElement && frameElement.nodeName.toLowerCase();
+    let tabIndex = element.tabIndex;
+
+    if (frameElement) {
+
+      // Frame elements inherit their tabindex onto all child elements.
+      if (frameElement.tabIndex === -1) {
+        return false;
+      }
+
+      // Webkit and Blink consider anything inside of an <object> element as non-tabbable.
+      if ((this.platform.BLINK || this.platform.WEBKIT) && frameType === 'object') {
+        return false;
+      }
+
+      // Webkit and Blink disable tabbing to an element inside of an invisible frame.
+      if ((this.platform.BLINK || this.platform.WEBKIT) && !this.isVisible(frameElement)) {
+        return false;
+      }
+
+    }
+
+    if (element.hasAttribute('contenteditable')) {
+      return tabIndex !== -1;
+    }
+
+    if (nodeName === 'iframe') {
+      // The frames may be tabbable depending on content, but it's not possibly to reliably
+      // investigate the content of the frames.
+      return false;
+    }
+
+    if (nodeName === 'audio') {
+      if (!element.hasAttribute('controls')) {
+        // By default an <audio> element without the controls enabled is not tabbable.
+        return false;
+      } else if (this.platform.BLINK) {
+        // In Blink <audio controls> elements are always tabbable.
+        return true;
+      }
+    }
+
+    if (nodeName === 'video') {
+      if (!element.hasAttribute('controls') && this.platform.TRIDENT) {
+        // In Trident a <video> element without the controls enabled is not tabbable.
+        return false;
+      } else if (this.platform.BLINK || this.platform.FIREFOX) {
+        // In Chrome and Firefox <video controls> elements are always tabbable.
+        return true;
+      }
+    }
+
+    if (nodeName === 'object' && (this.platform.BLINK || this.platform.WEBKIT)) {
+      // In all Blink and WebKit based browsers <object> elements are never tabbable.
+      return false;
+    }
+
+    // In iOS the browser only considers some specific elements as tabbable.
+    if (this.platform.WEBKIT && this.platform.IOS && !isPotentiallyTabbable(element)) {
+      return false;
+    }
+
+    return tabIndex >= 0;
   }
 
   /** Gets whether an element can be focused by the user. */
@@ -59,6 +129,7 @@ export class InteractivityChecker {
     // Again, naive approach that does not capture many edge cases and browser quirks.
     return isPotentiallyFocusable(element) && !this.isDisabled(element) && this.isVisible(element);
   }
+
 }
 
 /** Gets whether an element's  */
@@ -106,6 +177,16 @@ function hasValidTabIndex(element: HTMLElement): boolean {
   return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));
 }
 
+function isPotentiallyTabbable(element: HTMLElement): boolean {
+  let nodeName = element.nodeName.toLowerCase();
+  let inputType = nodeName === 'input' && (element as HTMLInputElement).type;
+
+  return inputType === 'text'
+      || inputType === 'password'
+      || nodeName === 'select'
+      || nodeName === 'textarea';
+}
+
 /**
  * Gets whether an element is potentially focusable without taking current visible/disabled state
  * into account.
@@ -122,3 +203,7 @@ function isPotentiallyFocusable(element: HTMLElement): boolean {
       hasValidTabIndex(element);
 }
 
+
+function getWindow(node: HTMLElement): Window {
+  return node.ownerDocument.defaultView || window;
+}
diff --git a/src/lib/core/core.ts b/src/lib/core/core.ts
index d75aaafdcc81..79e84e73c769 100644
--- a/src/lib/core/core.ts
+++ b/src/lib/core/core.ts
@@ -29,6 +29,9 @@ export {DomPortalHost} from './portal/dom-portal-host';
 // Projection
 export * from './projection/projection';
 
+// Platform
+export * from './platform/platform';
+
 // Overlay
 export {Overlay, OVERLAY_PROVIDERS} from './overlay/overlay';
 export {OverlayContainer} from './overlay/overlay-container';
diff --git a/src/lib/core/platform/platform.ts b/src/lib/core/platform/platform.ts
new file mode 100644
index 000000000000..051bf4359425
--- /dev/null
+++ b/src/lib/core/platform/platform.ts
@@ -0,0 +1,29 @@
+import {Injectable, NgModule, ModuleWithProviders} from '@angular/core';
+
+// Declare window with type of any.
+declare const window: any;
+
+@Injectable()
+export class MdPlatform {
+
+  /* Layout Engines */
+  BLINK = !!(window.chrome || (window.Intl && (window.Intl as any).v8BreakIterator)) && window.CSS;
+  WEBKIT = /AppleWebKit/i.test(navigator.userAgent) && !this.BLINK;
+  TRIDENT = /(msie|trident)/i.test(navigator.userAgent);
+
+  /* Browsers and Platform Types */
+  ANDROID = /android/i.test(navigator.userAgent);
+  IOS = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+  FIREFOX = /(firefox|minefield)/i.test(navigator.userAgent);
+
+}
+
+@NgModule({})
+export class PlatformModule {
+  static forRoot(): ModuleWithProviders {
+    return {
+      ngModule: PlatformModule,
+      providers: [MdPlatform],
+    };
+  }
+}
diff --git a/src/lib/dialog/dialog.ts b/src/lib/dialog/dialog.ts
index a71b260e021d..9df83d47d501 100644
--- a/src/lib/dialog/dialog.ts
+++ b/src/lib/dialog/dialog.ts
@@ -13,9 +13,8 @@ import {MdDialogConfig} from './dialog-config';
 import {MdDialogRef} from './dialog-ref';
 import {DialogInjector} from './dialog-injector';
 import {MdDialogContainer} from './dialog-container';
-import {A11yModule, InteractivityChecker} from '../core';
+import {A11yModule, InteractivityChecker, MdPlatform} from '../core';
 import {extendObject} from '../core/util/object-extend';
-
 export {MdDialogConfig} from './dialog-config';
 export {MdDialogRef} from './dialog-ref';
 
@@ -150,7 +149,7 @@ export class MdDialogModule {
   static forRoot(): ModuleWithProviders {
     return {
       ngModule: MdDialogModule,
-      providers: [MdDialog, OVERLAY_PROVIDERS, InteractivityChecker],
+      providers: [MdDialog, OVERLAY_PROVIDERS, InteractivityChecker, MdPlatform],
     };
   }
 }
diff --git a/src/lib/module.ts b/src/lib/module.ts
index 31d18001e089..c601f58ef656 100644
--- a/src/lib/module.ts
+++ b/src/lib/module.ts
@@ -31,6 +31,7 @@ import {MdToolbarModule} from './toolbar/index';
 import {MdTooltipModule} from './tooltip/index';
 import {MdMenuModule} from './menu/index';
 import {MdDialogModule} from './dialog/index';
+import {PlatformModule} from './core/platform/platform';
 
 
 const MATERIAL_MODULES = [
@@ -60,6 +61,7 @@ const MATERIAL_MODULES = [
   PortalModule,
   RtlModule,
   A11yModule,
+  PlatformModule,
   ProjectionModule,
   StyleCompatibilityModule,
 ];
@@ -94,6 +96,7 @@ const MATERIAL_MODULES = [
     MdSlideToggleModule.forRoot(),
     MdSnackBarModule.forRoot(),
     MdTooltipModule.forRoot(),
+    PlatformModule.forRoot(),
     OverlayModule.forRoot(),
     StyleCompatibilityModule.forRoot(),
   ],